-- Copyright (c) 2024 Huawei Technologies Co., Ltd.
-- openUBMC is licensed under Mulan PSL v2.
-- You can use this software according to the terms and conditions of the Mulan PSL v2.
-- You may obtain a copy of Mulan PSL v2 at:
--          http://license.coscl.org.cn/MulanPSL2
-- THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
-- EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
-- MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
-- See the Mulan PSL v2 for more details.
local mdb = require 'mc.mdb'
local class = require 'mc.class_mgnt'
local privilege = require 'mc.privilege'

local controller_class_types = require 'class.types.Controller'
local disk_array_class_types = require 'class.types.DiskArray'
local drive_class_types = require 'class.types.Drive'
local drives_class_types = require 'class.types.Drives'
local volume_class_types = require 'class.types.Volume'
local battery_class_types = require 'class.types.Battery'
local nvme_class_types = require 'class.types.Nvme'
local virtual_vpd_connect_class_types = require 'class.types.VirtualVPDConnect'
local drive_info_table_class_types = require 'class.types.DriveInfoTable'
local drives_table_info_class_types = require 'class.types.DrivesTableInfo'
local storage_reset_class_types = require 'class.types.StorageReset'
local global_storage_config_table_class_types = require 'class.types.GlobalStorageConfigTable'
local nv_me_config_class_types = require 'class.types.NVMeConfig'
local storage_setting_class_types = require 'class.types.StorageSetting'
local storage_config_intf_types = require 'storage.json_types.StorageConfig'
local storage_diagnose_intf_types = require 'storage.json_types.StorageDiagnose'
local phy_bit_error_intf_types = require 'storage.json_types.PhyBitError'
local record_drive_spare_block_intf_types = require 'storage.json_types.RecordDriveSpareBlock'
local release_storage_controller_intf_types = require 'storage.json_types.ReleaseStorageController'
local release_storage_drive_intf_types = require 'storage.json_types.ReleaseStorageDrive'
local properties_intf_types = require 'mdb.bmc.kepler.Object.PropertiesInterface'
local systems_storage_controller_intf_types = require 'storage.json_types.SystemsStorageController'
local driver_intf_types = require 'storage.json_types.Driver'
local chip_intf_types = require 'storage.json_types.Chip'
local consistency_check_intf_types = require 'storage.json_types.ConsistencyCheck'
local volume_manage_intf_types = require 'storage.json_types.VolumeManage'
local controller_status_intf_types = require 'storage.json_types.ControllerStatus'
local battery_status_intf_types = require 'storage.json_types.BatteryStatus'
local retirement_intf_types = require 'storage.json_types.Retirement'
local hardware_intf_types = require 'storage.json_types.Hardware'
local phy_error_intf_types = require 'storage.json_types.PhyError'
local disk_array_intf_types = require 'storage.json_types.DiskArray'
local systems_storage_drive_intf_types = require 'storage.json_types.SystemsStorageDrive'
local addr_info_intf_types = require 'storage.json_types.AddrInfo'
local drive_status_intf_types = require 'storage.json_types.DriveStatus'
local sassmart_intf_types = require 'storage.json_types.SASSMART'
local metric_intf_types = require 'storage.json_types.Metric'
local drive_sub_health_intf_types = require 'storage.json_types.DriveSubHealth'
local nv_me_intf_types = require 'storage.json_types.NVMe'
local nv_me_smart_intf_types = require 'storage.json_types.NVMeSMART'
local drive_diagnose_intf_types = require 'storage.json_types.DriveDiagnose'
local drives_intf_types = require 'storage.json_types.Drives'
local replica_drive_intf_types = require 'storage.json_types.ReplicaDrive'
local volume_intf_types = require 'storage.json_types.Volume'
local battery_intf_types = require 'storage.json_types.Battery'
local sas_metrics_intf_types = require 'storage.json_types.SASMetrics'
local disk_partition_intf_types = require 'storage.json_types.DiskPartition'
local storage_setting_intf_types = require 'storage.json_types.StorageSetting'

local StorageConfig = {
    ['table_name'] = 't_storage_config_table_info',
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.StorageConfig'] = {
            ['StorageConfigReady'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = storage_config_intf_types.StorageConfigReady
            },
            ['VolumesStateAbnormal'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = storage_config_intf_types.VolumesStateAbnormal
            },
            ['DiskPartitionUsagePercentageThreshold'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = false,
                ['privilege'] = {['read'] = {'ReadOnly'}, ['write'] = {'BasicSetting'}},
                ['default'] = 100,
                ['validator'] = storage_config_intf_types.DiskPartitionUsagePercentageThreshold
            }
        },
        ['bmc.kepler.Systems.Storage.Diagnose'] = {
            ['PhyErrorEnabled'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['primaryKey'] = true,
                ['default'] = true,
                ['validator'] = storage_diagnose_intf_types.PhyErrorEnabled
            },
            ['PhyErrorInterval'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['default'] = 1800,
                ['validator'] = storage_diagnose_intf_types.PhyErrorInterval
            },
            ['PhyErrorMaxRecord'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['default'] = 20,
                ['validator'] = storage_diagnose_intf_types.PhyErrorMaxRecord
            },
            ['PhyErrorThreshold'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['default'] = 100,
                ['validator'] = storage_diagnose_intf_types.PhyErrorThreshold
            },
            ['MaxPhyErrorLogFileRotationCount'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['default'] = 10,
                ['validator'] = storage_diagnose_intf_types.MaxPhyErrorLogFileRotationCount
            },
            ['PhyErrorSelUnlimitFlag'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['validator'] = storage_diagnose_intf_types.PhyErrorSelUnlimitFlag
            }
        },
        ['bmc.kepler.Debug.Storage.PhyBitError'] = {
            ['FileMockEnabled'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'PoweroffPer'},
                ['validator'] = phy_bit_error_intf_types.FileMockEnabled
            }
        },
        ['bmc.kepler.Debug.Storage.RecordDriveSpareBlock'] = {},
        ['bmc.kepler.Release.Storage.Controller'] = {},
        ['bmc.kepler.Release.Storage.Drive'] = {},
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_method_configs'] = {
        ['bmc.kepler.Debug.Storage.PhyBitError'] = {
            ['MockData'] = {
                ['req'] = {
                    {['baseType'] = 'U8', ['param'] = 'ControllerId'}, {['baseType'] = 'U8', ['param'] = 'ExpanderId'},
                    {['baseType'] = 'String', ['param'] = 'FilePath'}
                },
                ['rsp'] = {{['baseType'] = 'U8', ['param'] = 'MockResult'}}
            }
        },
        ['bmc.kepler.Debug.Storage.RecordDriveSpareBlock'] = {
            ['MockRecordSpareBlock'] = {
                ['privilege'] = {'BasicSetting'},
                ['req'] = {
                    {['baseType'] = 'U8', ['param'] = 'Id'}, {['baseType'] = 'U8', ['param'] = 'SlcSpareBlock'},
                    {['baseType'] = 'U8', ['param'] = 'TlcSpareBlock'}
                },
                ['rsp'] = {}
            }
        },
        ['bmc.kepler.Release.Storage.Controller'] = {
            ['GetControllerInfo'] = {
                ['req'] = {
                    {['baseType'] = 'U8', ['displayDescription'] = 'The Id of controller.', ['param'] = 'ControllerId'}
                },
                ['rsp'] = {{['baseType'] = 'Dictionary', ['$ref'] = '#/defs/Details', ['param'] = 'Details'}},
                ['displayDescription'] = 'Get the running information of controller.',
                ['cmdName'] = 'getctrlinfo'
            }
        },
        ['bmc.kepler.Release.Storage.Drive'] = {
            ['GetDriveDetails'] = {
                ['req'] = {
                    {['baseType'] = 'String', ['displayDescription'] = 'The name of drive.', ['param'] = 'DriveName'}
                },
                ['rsp'] = {
                    {['baseType'] = 'Array', ['items'] = {['$ref'] = '#/defs/DriveItem'}, ['param'] = 'DriveInfos'}
                },
                ['displayDescription'] = 'Get the drive details.',
                ['cmdName'] = 'getdrivedetails'
            }
        }
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.StorageConfig'] = {
            ['property_defaults'] = {
                ['StorageConfigReady'] = storage_config_intf_types.StorageConfigReady.default[1],
                ['VolumesStateAbnormal'] = storage_config_intf_types.VolumesStateAbnormal.default[1],
                ['DiskPartitionUsagePercentageThreshold'] = 100
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['props'] = {
                    ['DiskPartitionUsagePercentageThreshold'] = {
                        ['read'] = privilege.ReadOnly,
                        ['write'] = privilege.BasicSetting
                    }
                }
            },
            ['interface_types'] = storage_config_intf_types
        },
        ['bmc.kepler.Systems.Storage.Diagnose'] = {
            ['property_defaults'] = {
                ['PhyErrorEnabled'] = true,
                ['PhyErrorInterval'] = 1800,
                ['PhyErrorMaxRecord'] = 20,
                ['PhyErrorThreshold'] = 100,
                ['MaxPhyErrorLogFileRotationCount'] = 10,
                ['PhyErrorSelUnlimitFlag'] = storage_diagnose_intf_types.PhyErrorSelUnlimitFlag.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = storage_diagnose_intf_types
        },
        ['bmc.kepler.Debug.Storage.PhyBitError'] = {
            ['property_defaults'] = {['FileMockEnabled'] = phy_bit_error_intf_types.FileMockEnabled.default[1]},
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = phy_bit_error_intf_types
        },
        ['bmc.kepler.Debug.Storage.RecordDriveSpareBlock'] = {
            ['property_defaults'] = {},
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {['MockRecordSpareBlock'] = privilege.BasicSetting}
            },
            ['interface_types'] = record_drive_spare_block_intf_types
        },
        ['bmc.kepler.Release.Storage.Controller'] = {
            ['property_defaults'] = {},
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = release_storage_controller_intf_types
        },
        ['bmc.kepler.Release.Storage.Drive'] = {
            ['property_defaults'] = {},
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = release_storage_drive_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local Controller = {
    ['table_name'] = 't_controller_info',
    ['alias_map'] = {
        ['ControllerName'] = {['original_name'] = 'Name', ['interface'] = 'bmc.kepler.Systems.Storage.Controller'},
        ['DriverName'] = {['original_name'] = 'Name', ['interface'] = 'bmc.kepler.Systems.Storage.Controller.Driver'},
        ['DriverVersion'] = {
            ['original_name'] = 'Version',
            ['interface'] = 'bmc.kepler.Systems.Storage.Controller.Driver'
        },
        ['ConsistencyCheckState'] = {
            ['original_name'] = 'State',
            ['interface'] = 'bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'
        },
        ['RetirementState'] = {['original_name'] = 'State', ['interface'] = 'bmc.kepler.LifeCycle.Retirement'},
        ['InventorySerialNumber'] = {
            ['original_name'] = 'SerialNumber',
            ['interface'] = 'bmc.kepler.Inventory.Hardware'
        },
        ['InventoryFirmwareVersion'] = {
            ['original_name'] = 'FirmwareVersion',
            ['interface'] = 'bmc.kepler.Inventory.Hardware'
        },
        ['InventoryModel'] = {['original_name'] = 'Model', ['interface'] = 'bmc.kepler.Inventory.Hardware'}
    },
    ['prop_configs'] = {
        ['RefChip'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Chip.BlockIO',
            ['validator'] = controller_class_types.RefChip
        },
        ['SystemId'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.SystemId
        },
        ['SocketId'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.SocketId
        },
        ['Segment'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.Segment
        },
        ['DevBus'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.DevBus
        },
        ['DevDevice'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.DevDevice
        },
        ['DevFunction'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.DevFunction
        },
        ['Eid'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = controller_class_types.Eid},
        ['Phyaddr'] = {['baseType'] = 'U16', ['readOnly'] = true, ['validator'] = controller_class_types.Phyaddr},
        ['CtrlOption1'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U32',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.CtrlOption1
        },
        ['CtrlOption2'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U32',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.CtrlOption2
        },
        ['CtrlOption3'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U32',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.CtrlOption3
        },
        ['SlotId'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['readOnly'] = true,
            ['validator'] = controller_class_types.SlotId
        }
    },
    ['default_props'] = {
        ['RefChip'] = controller_class_types.RefChip.default[1],
        ['SystemId'] = controller_class_types.SystemId.default[1],
        ['SocketId'] = controller_class_types.SocketId.default[1],
        ['Segment'] = controller_class_types.Segment.default[1],
        ['DevBus'] = controller_class_types.DevBus.default[1],
        ['DevDevice'] = controller_class_types.DevDevice.default[1],
        ['DevFunction'] = controller_class_types.DevFunction.default[1],
        ['Eid'] = controller_class_types.Eid.default[1],
        ['Phyaddr'] = controller_class_types.Phyaddr.default[1],
        ['CtrlOption1'] = controller_class_types.CtrlOption1.default[1],
        ['CtrlOption2'] = controller_class_types.CtrlOption2.default[1],
        ['CtrlOption3'] = controller_class_types.CtrlOption3.default[1],
        ['SlotId'] = controller_class_types.SlotId.default[1]
    },
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.Controller'] = {
            ['Id'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPerRetain'},
                ['default'] = 255,
                ['validator'] = systems_storage_controller_intf_types.Id
            },
            ['Type'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.Type
            },
            ['TypeId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_controller_intf_types.TypeId
            },
            ['DeviceName'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['primaryKey'] = true,
                ['validator'] = systems_storage_controller_intf_types.DeviceName
            },
            ['Position'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_controller_intf_types.Position
            },
            ['TemperatureCelsius'] = {
                ['baseType'] = 'S16',
                ['readOnly'] = true,
                ['options'] = {['volatile'] = true, ['emitsChangedSignal'] = 'true'},
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_controller_intf_types.TemperatureCelsius
            },
            ['TemperatureAbnormal'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_controller_intf_types.TemperatureAbnormal
            },
            ['Name'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['alias'] = 'ControllerName',
                ['validator'] = systems_storage_controller_intf_types.Name
            },
            ['OOBSupport'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'PoweroffPer'},
                ['validator'] = systems_storage_controller_intf_types.OOBSupport
            },
            ['FirmwareVersion'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.FirmwareVersion
            },
            ['SupportedMode'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.SupportedMode
            },
            ['MemorySizeMiB'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.MemorySizeMiB
            },
            ['DeviceInterface'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.DeviceInterface
            },
            ['SASAddr'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.SASAddr
            },
            ['SerialNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_controller_intf_types.SerialNumber
            },
            ['MaxStripSizeBytes'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.MaxStripSizeBytes
            },
            ['MinStripSizeBytes'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.MinStripSizeBytes
            },
            ['NVDataVersion'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.NVDataVersion
            },
            ['MaintainPDFailHistrory'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.MaintainPDFailHistrory
            },
            ['PCIeLinkWidth'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.PCIeLinkWidth
            },
            ['UnconfiguredDriveWriteCachePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.UnconfiguredDriveWriteCachePolicy
            },
            ['HBADriveWriteCachePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.HBADriveWriteCachePolicy
            },
            ['ConfiguredDriveWriteCachePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.ConfiguredDriveWriteCachePolicy
            },
            ['SupportedRAIDTypes'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.SupportedRAIDTypes
            },
            ['SmarterCopyBackState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.SmarterCopyBackState
            },
            ['CopyBackState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.CopyBackState
            },
            ['BootDevices'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.BootDevices
            },
            ['HardwareRevision'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.HardwareRevision
            },
            ['UncorrectableParityErrorCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'true'},
                ['validator'] = systems_storage_controller_intf_types.UncorrectableParityErrorCount
            },
            ['HotSpareActivationMode'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.HotSpareActivationMode
            },
            ['NoBatteryWriteCacheEnabled'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['default'] = 255,
                ['validator'] = systems_storage_controller_intf_types.NoBatteryWriteCacheEnabled
            },
            ['ReadCachePercent'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['default'] = 255,
                ['validator'] = systems_storage_controller_intf_types.ReadCachePercent
            },
            ['JBODState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.JBODState
            },
            ['CachePinnedState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.CachePinnedState
            },
            ['DDREccCount'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.DDREccCount
            },
            ['WorkMode'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.WorkMode
            },
            ['RefDrives'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.RefDrives
            },
            ['BOMNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_controller_intf_types.BOMNumber
            },
            ['CryptoEraseSupported'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = systems_storage_controller_intf_types.CryptoEraseSupported
            },
            ['EpdSupported'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = systems_storage_controller_intf_types.EpdSupported
            },
            ['JbodSupported'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = systems_storage_controller_intf_types.JbodSupported
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.Driver'] = {
            ['Name'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'DriverName',
                ['validator'] = driver_intf_types.Name
            },
            ['Version'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'DriverVersion',
                ['validator'] = driver_intf_types.Version
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.Chip'] = {
            ['Model'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = chip_intf_types.Model
            },
            ['ChipManufacturer'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = chip_intf_types.ChipManufacturer
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'] = {
            ['State'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['alias'] = 'ConsistencyCheckState',
                ['validator'] = consistency_check_intf_types.State
            },
            ['PeriodOfHours'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = consistency_check_intf_types.PeriodOfHours
            },
            ['Rate'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = consistency_check_intf_types.Rate},
            ['AutoRepairEnabled'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = consistency_check_intf_types.AutoRepairEnabled
            },
            ['RunningStatus'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = consistency_check_intf_types.RunningStatus
            },
            ['TotalVolumeCounts'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = consistency_check_intf_types.TotalVolumeCounts
            },
            ['CompletedVolumeCounts'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = consistency_check_intf_types.CompletedVolumeCounts
            },
            ['DelayToStart'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = consistency_check_intf_types.DelayToStart
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.VolumeManage'] = {
            ['CreateVolumeSupported'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.CreateVolumeSupported
            },
            ['SupportedReadPolicyList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.SupportedReadPolicyList
            },
            ['DefaultReadPolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.DefaultReadPolicy
            },
            ['ReadPolicyWritable'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.ReadPolicyWritable
            },
            ['SupportedWritePolicyList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.SupportedWritePolicyList
            },
            ['DefaultWritePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.DefaultWritePolicy
            },
            ['WritePolicyWritable'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.WritePolicyWritable
            },
            ['SupportedIOPolicyList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.SupportedIOPolicyList
            },
            ['DefaultIOPolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.DefaultIOPolicy
            },
            ['IOPolicyWritable'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.IOPolicyWritable
            },
            ['SupportedAccessPolicyList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.SupportedAccessPolicyList
            },
            ['DefaultAccessPolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.DefaultAccessPolicy
            },
            ['AccessPolicyWritable'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.AccessPolicyWritable
            },
            ['SupportedDriveCachePolicyList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.SupportedDriveCachePolicyList
            },
            ['DefaultDriveCachePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.DefaultDriveCachePolicy
            },
            ['DriveCachePolicyWritable'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['validator'] = volume_manage_intf_types.DriveCachePolicyWritable
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.ControllerStatus'] = {
            ['FaultCode'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = controller_status_intf_types.FaultCode
            },
            ['CommunicationLoss'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = controller_status_intf_types.CommunicationLoss
            },
            ['Health'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = controller_status_intf_types.Health
            },
            ['FaultCodeByBios'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'ResetPer'},
                ['validator'] = controller_status_intf_types.FaultCodeByBios
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.BatteryStatus'] = {
            ['BatteryPresence'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'ResetPer'},
                ['default'] = 255,
                ['validator'] = battery_status_intf_types.BatteryPresence
            },
            ['BatteryFault'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = battery_status_intf_types.BatteryFault
            },
            ['BatteryHealth'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = battery_status_intf_types.BatteryHealth
            }
        },
        ['bmc.kepler.LifeCycle.Retirement'] = {
            ['Media'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['enum'] = {'Flash', 'SSD', 'Eeprom', 'HDD'},
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = retirement_intf_types.Media
            },
            ['Source'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['enum'] = {'Huawei', 'User'},
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = retirement_intf_types.Source
            },
            ['Description'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['enum'] = {'Clear', 'Perge'},
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = retirement_intf_types.Description
            },
            ['Method'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['enum'] = {'OverWrite', 'BlockErase', 'CryptoErase'},
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = retirement_intf_types.Method
            },
            ['Result'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['enum'] = {'Successful', 'Failed'},
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = retirement_intf_types.Result
            },
            ['Progress'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = retirement_intf_types.Progress
            },
            ['State'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['enum'] = {'Idle', 'Running', 'Finish'},
                ['default'] = 'Idle',
                ['alias'] = 'RetirementState',
                ['validator'] = retirement_intf_types.State
            }
        },
        ['bmc.kepler.Inventory.Hardware'] = {
            ['AssetType'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.AssetType
            },
            ['AssetName'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.AssetName
            },
            ['SerialNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventorySerialNumber',
                ['validator'] = hardware_intf_types.SerialNumber
            },
            ['FirmwareVersion'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventoryFirmwareVersion',
                ['validator'] = hardware_intf_types.FirmwareVersion
            },
            ['PCBVersion'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.PCBVersion
            },
            ['Manufacturer'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.Manufacturer
            },
            ['AssetTag'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = hardware_intf_types.AssetTag},
            ['PartNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.PartNumber
            },
            ['ManufactureDate'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.ManufactureDate
            },
            ['Slot'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = hardware_intf_types.Slot},
            ['Model'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventoryModel',
                ['validator'] = hardware_intf_types.Model
            },
            ['UUID'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = hardware_intf_types.UUID}
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_method_configs'] = {
        ['bmc.kepler.Systems.Storage.Controller'] = {
            ['SetBootDevices'] = {
                ['req'] = {
                    {['baseType'] = 'String', ['param'] = 'PriorityDriveName'},
                    {['baseType'] = 'String', ['param'] = 'SecondaryDriveName'}
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetJBODState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'State'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetSmarterCopyBackState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'State'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['RestoreDefaultSettings'] = {['req'] = {}, ['rsp'] = {}, ['privilege'] = {'BasicSetting'}},
            ['SetCopybackState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'State'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetMaintainPDFailHistoryState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'State'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetWorkMode'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'Mode'}, {['baseType'] = 'U8', ['param'] = 'ProfileId'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['ImportForeignConfig'] = {['req'] = {}, ['rsp'] = {}, ['privilege'] = {'BasicSetting'}},
            ['DumpLog'] = {
                ['req'] = {},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['ClearForeignConfig'] = {['req'] = {}, ['rsp'] = {}, ['privilege'] = {'BasicSetting'}},
            ['SetNoBatteryWriteCache'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'NoBatteryWriteCacheEnabled'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetReadCachePercent'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'ReadCachePercent'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetWriteCachePolicy'] = {
                ['req'] = {
                    {
                        ['baseType'] = 'String',
                        ['enum'] = {
                            'ConfiguredDriveWriteCachePolicy', 'UnconfiguredDriveWriteCachePolicy',
                            'HBADriveWriteCachePolicy'
                        },
                        ['param'] = 'Type'
                    }, {['baseType'] = 'String', ['param'] = 'WriteCachePolicy'}
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'] = {
            ['Enable'] = {
                ['req'] = {
                    {['baseType'] = 'U16', ['param'] = 'Period'}, {['baseType'] = 'U8', ['param'] = 'Rate'},
                    {['baseType'] = 'U8', ['param'] = 'AutoRepairedEnabled'},
                    {['baseType'] = 'U32', ['param'] = 'DelayToStart'}
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['Disable'] = {['req'] = {}, ['rsp'] = {}, ['privilege'] = {'BasicSetting'}},
            ['SetParameters'] = {
                ['req'] = {
                    {['baseType'] = 'U16', ['param'] = 'Period'}, {['baseType'] = 'U8', ['param'] = 'Rate'},
                    {['baseType'] = 'U8', ['param'] = 'AutoRepairedEnabled'}
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            }
        },
        ['bmc.kepler.Systems.Storage.Controller.VolumeManage'] = {
            ['CreateVolumeInNewArray'] = {
                ['req'] = {
                    {['baseType'] = 'U8[]', ['param'] = 'DriveLists'}, {['baseType'] = 'U8', ['param'] = 'RaidType'},
                    {['baseType'] = 'U8', ['param'] = 'SpanDepth'}, {['baseType'] = 'String', ['param'] = 'Name'},
                    {['baseType'] = 'U32', ['param'] = 'Capacity'}, {['baseType'] = 'U8', ['param'] = 'CapacityUnit'},
                    {['baseType'] = 'U8', ['param'] = 'StripSize'}, {['baseType'] = 'U8', ['param'] = 'ReadPolicy'},
                    {['baseType'] = 'U8', ['param'] = 'WritePolicy'}, {['baseType'] = 'U8', ['param'] = 'IOPolicy'},
                    {['baseType'] = 'U8', ['param'] = 'AccessPolicy'},
                    {['baseType'] = 'U8', ['param'] = 'DiskCachePolicy'}, {['baseType'] = 'U8', ['param'] = 'InitType'},
                    {['baseType'] = 'U8', ['param'] = 'Accelerator'}
                },
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['DeleteVolume'] = {
                ['req'] = {{['baseType'] = 'U16', ['param'] = 'VolumeId'}},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['CreateVolumeInExisingtArray'] = {
                ['req'] = {
                    {['baseType'] = 'U16', ['param'] = 'ArrayId'}, {['baseType'] = 'U8', ['param'] = 'BlockIndex'},
                    {['baseType'] = 'U8', ['param'] = 'RaidType'}, {['baseType'] = 'U8', ['param'] = 'SpanDepth'},
                    {['baseType'] = 'String', ['param'] = 'Name'}, {['baseType'] = 'U32', ['param'] = 'Capacity'},
                    {['baseType'] = 'U8', ['param'] = 'CapacityUnit'}, {['baseType'] = 'U8', ['param'] = 'StripSize'},
                    {['baseType'] = 'U8', ['param'] = 'ReadPolicy'}, {['baseType'] = 'U8', ['param'] = 'WritePolicy'},
                    {['baseType'] = 'U8', ['param'] = 'IOPolicy'}, {['baseType'] = 'U8', ['param'] = 'AccessPolicy'},
                    {['baseType'] = 'U8', ['param'] = 'DiskCachePolicy'}, {['baseType'] = 'U8', ['param'] = 'InitType'},
                    {['baseType'] = 'U8', ['param'] = 'Accelerator'}
                },
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['CreateCachecadeVolume'] = {
                ['req'] = {
                    {['baseType'] = 'U8[]', ['param'] = 'DriveLists'}, {['baseType'] = 'U8', ['param'] = 'RaidType'},
                    {['baseType'] = 'String', ['param'] = 'Name'}, {['baseType'] = 'U8', ['param'] = 'WritePolicy'},
                    {['baseType'] = 'U16', ['param'] = 'ArrayId'}, {['baseType'] = 'U32', ['param'] = 'Capacity'},
                    {['baseType'] = 'U8', ['param'] = 'CapacityUnit'},
                    {['baseType'] = 'U16', ['param'] = 'AssociateLd'},
                    {['baseType'] = 'U8', ['param'] = 'CacheLineSize'}
                },
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}}
            }
        },
        ['bmc.kepler.LifeCycle.Retirement'] = {
            ['DataWipe'] = {['req'] = {}, ['rsp'] = {}},
            ['GetReport'] = {
                ['req'] = {},
                ['rsp'] = {{['baseType'] = 'Dictionary', ['$ref'] = '#/defs/DataWipeReportDict', ['param'] = 'Report'}}
            }
        }
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Controllers/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.Controller'] = {
            ['property_defaults'] = {
                ['Id'] = 255,
                ['Type'] = systems_storage_controller_intf_types.Type.default[1],
                ['TypeId'] = systems_storage_controller_intf_types.TypeId.default[1],
                ['DeviceName'] = systems_storage_controller_intf_types.DeviceName.default[1],
                ['Position'] = systems_storage_controller_intf_types.Position.default[1],
                ['TemperatureCelsius'] = systems_storage_controller_intf_types.TemperatureCelsius.default[1],
                ['TemperatureAbnormal'] = systems_storage_controller_intf_types.TemperatureAbnormal.default[1],
                ['Name'] = systems_storage_controller_intf_types.Name.default[1],
                ['OOBSupport'] = systems_storage_controller_intf_types.OOBSupport.default[1],
                ['FirmwareVersion'] = systems_storage_controller_intf_types.FirmwareVersion.default[1],
                ['SupportedMode'] = systems_storage_controller_intf_types.SupportedMode.default[1],
                ['MemorySizeMiB'] = systems_storage_controller_intf_types.MemorySizeMiB.default[1],
                ['DeviceInterface'] = systems_storage_controller_intf_types.DeviceInterface.default[1],
                ['SASAddr'] = systems_storage_controller_intf_types.SASAddr.default[1],
                ['SerialNumber'] = systems_storage_controller_intf_types.SerialNumber.default[1],
                ['MaxStripSizeBytes'] = systems_storage_controller_intf_types.MaxStripSizeBytes.default[1],
                ['MinStripSizeBytes'] = systems_storage_controller_intf_types.MinStripSizeBytes.default[1],
                ['NVDataVersion'] = systems_storage_controller_intf_types.NVDataVersion.default[1],
                ['MaintainPDFailHistrory'] = systems_storage_controller_intf_types.MaintainPDFailHistrory.default[1],
                ['PCIeLinkWidth'] = systems_storage_controller_intf_types.PCIeLinkWidth.default[1],
                ['UnconfiguredDriveWriteCachePolicy'] = systems_storage_controller_intf_types.UnconfiguredDriveWriteCachePolicy
                    .default[1],
                ['HBADriveWriteCachePolicy'] = systems_storage_controller_intf_types.HBADriveWriteCachePolicy.default[1],
                ['ConfiguredDriveWriteCachePolicy'] = systems_storage_controller_intf_types.ConfiguredDriveWriteCachePolicy
                    .default[1],
                ['SupportedRAIDTypes'] = systems_storage_controller_intf_types.SupportedRAIDTypes.default[1],
                ['SmarterCopyBackState'] = systems_storage_controller_intf_types.SmarterCopyBackState.default[1],
                ['CopyBackState'] = systems_storage_controller_intf_types.CopyBackState.default[1],
                ['BootDevices'] = systems_storage_controller_intf_types.BootDevices.default[1],
                ['HardwareRevision'] = systems_storage_controller_intf_types.HardwareRevision.default[1],
                ['UncorrectableParityErrorCount'] = systems_storage_controller_intf_types.UncorrectableParityErrorCount
                    .default[1],
                ['HotSpareActivationMode'] = systems_storage_controller_intf_types.HotSpareActivationMode.default[1],
                ['NoBatteryWriteCacheEnabled'] = 255,
                ['ReadCachePercent'] = 255,
                ['JBODState'] = systems_storage_controller_intf_types.JBODState.default[1],
                ['CachePinnedState'] = systems_storage_controller_intf_types.CachePinnedState.default[1],
                ['DDREccCount'] = systems_storage_controller_intf_types.DDREccCount.default[1],
                ['WorkMode'] = systems_storage_controller_intf_types.WorkMode.default[1],
                ['RefDrives'] = systems_storage_controller_intf_types.RefDrives.default[1],
                ['BOMNumber'] = systems_storage_controller_intf_types.BOMNumber.default[1],
                ['CryptoEraseSupported'] = systems_storage_controller_intf_types.CryptoEraseSupported.default[1],
                ['EpdSupported'] = systems_storage_controller_intf_types.EpdSupported.default[1],
                ['JbodSupported'] = systems_storage_controller_intf_types.JbodSupported.default[1]
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['SetBootDevices'] = privilege.BasicSetting,
                    ['SetJBODState'] = privilege.BasicSetting,
                    ['SetSmarterCopyBackState'] = privilege.BasicSetting,
                    ['RestoreDefaultSettings'] = privilege.BasicSetting,
                    ['SetCopybackState'] = privilege.BasicSetting,
                    ['SetMaintainPDFailHistoryState'] = privilege.BasicSetting,
                    ['SetWorkMode'] = privilege.BasicSetting,
                    ['ImportForeignConfig'] = privilege.BasicSetting,
                    ['DumpLog'] = privilege.BasicSetting,
                    ['ClearForeignConfig'] = privilege.BasicSetting,
                    ['SetNoBatteryWriteCache'] = privilege.BasicSetting,
                    ['SetReadCachePercent'] = privilege.BasicSetting,
                    ['SetWriteCachePolicy'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = systems_storage_controller_intf_types
        },
        ['bmc.kepler.Systems.Storage.Controller.Driver'] = {
            ['property_defaults'] = {
                ['Name'] = driver_intf_types.Name.default[1],
                ['Version'] = driver_intf_types.Version.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = driver_intf_types
        },
        ['bmc.kepler.Systems.Storage.Controller.Chip'] = {
            ['property_defaults'] = {
                ['Model'] = chip_intf_types.Model.default[1],
                ['ChipManufacturer'] = chip_intf_types.ChipManufacturer.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = chip_intf_types
        },
        ['bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'] = {
            ['property_defaults'] = {
                ['State'] = consistency_check_intf_types.State.default[1],
                ['PeriodOfHours'] = consistency_check_intf_types.PeriodOfHours.default[1],
                ['Rate'] = consistency_check_intf_types.Rate.default[1],
                ['AutoRepairEnabled'] = consistency_check_intf_types.AutoRepairEnabled.default[1],
                ['RunningStatus'] = consistency_check_intf_types.RunningStatus.default[1],
                ['TotalVolumeCounts'] = consistency_check_intf_types.TotalVolumeCounts.default[1],
                ['CompletedVolumeCounts'] = consistency_check_intf_types.CompletedVolumeCounts.default[1],
                ['DelayToStart'] = consistency_check_intf_types.DelayToStart.default[1]
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['Enable'] = privilege.BasicSetting,
                    ['Disable'] = privilege.BasicSetting,
                    ['SetParameters'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = consistency_check_intf_types
        },
        ['bmc.kepler.Systems.Storage.Controller.VolumeManage'] = {
            ['property_defaults'] = {
                ['CreateVolumeSupported'] = volume_manage_intf_types.CreateVolumeSupported.default[1],
                ['SupportedReadPolicyList'] = volume_manage_intf_types.SupportedReadPolicyList.default[1],
                ['DefaultReadPolicy'] = volume_manage_intf_types.DefaultReadPolicy.default[1],
                ['ReadPolicyWritable'] = volume_manage_intf_types.ReadPolicyWritable.default[1],
                ['SupportedWritePolicyList'] = volume_manage_intf_types.SupportedWritePolicyList.default[1],
                ['DefaultWritePolicy'] = volume_manage_intf_types.DefaultWritePolicy.default[1],
                ['WritePolicyWritable'] = volume_manage_intf_types.WritePolicyWritable.default[1],
                ['SupportedIOPolicyList'] = volume_manage_intf_types.SupportedIOPolicyList.default[1],
                ['DefaultIOPolicy'] = volume_manage_intf_types.DefaultIOPolicy.default[1],
                ['IOPolicyWritable'] = volume_manage_intf_types.IOPolicyWritable.default[1],
                ['SupportedAccessPolicyList'] = volume_manage_intf_types.SupportedAccessPolicyList.default[1],
                ['DefaultAccessPolicy'] = volume_manage_intf_types.DefaultAccessPolicy.default[1],
                ['AccessPolicyWritable'] = volume_manage_intf_types.AccessPolicyWritable.default[1],
                ['SupportedDriveCachePolicyList'] = volume_manage_intf_types.SupportedDriveCachePolicyList.default[1],
                ['DefaultDriveCachePolicy'] = volume_manage_intf_types.DefaultDriveCachePolicy.default[1],
                ['DriveCachePolicyWritable'] = volume_manage_intf_types.DriveCachePolicyWritable.default[1]
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['CreateVolumeInNewArray'] = privilege.BasicSetting,
                    ['DeleteVolume'] = privilege.BasicSetting,
                    ['CreateVolumeInExisingtArray'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = volume_manage_intf_types
        },
        ['bmc.kepler.Systems.Storage.Controller.ControllerStatus'] = {
            ['property_defaults'] = {
                ['FaultCode'] = controller_status_intf_types.FaultCode.default[1],
                ['CommunicationLoss'] = controller_status_intf_types.CommunicationLoss.default[1],
                ['Health'] = controller_status_intf_types.Health.default[1],
                ['FaultCodeByBios'] = controller_status_intf_types.FaultCodeByBios.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = controller_status_intf_types
        },
        ['bmc.kepler.Systems.Storage.Controller.BatteryStatus'] = {
            ['property_defaults'] = {
                ['BatteryPresence'] = 255,
                ['BatteryFault'] = 255,
                ['BatteryHealth'] = battery_status_intf_types.BatteryHealth.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = battery_status_intf_types
        },
        ['bmc.kepler.LifeCycle.Retirement'] = {
            ['property_defaults'] = {
                ['Media'] = retirement_intf_types.Media.default[1],
                ['Source'] = retirement_intf_types.Source.default[1],
                ['Description'] = retirement_intf_types.Description.default[1],
                ['Method'] = retirement_intf_types.Method.default[1],
                ['Result'] = retirement_intf_types.Result.default[1],
                ['Progress'] = retirement_intf_types.Progress.default[1],
                ['State'] = 'Idle'
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = retirement_intf_types
        },
        ['bmc.kepler.Inventory.Hardware'] = {
            ['property_defaults'] = {
                ['AssetType'] = hardware_intf_types.AssetType.default[1],
                ['AssetName'] = hardware_intf_types.AssetName.default[1],
                ['SerialNumber'] = hardware_intf_types.SerialNumber.default[1],
                ['FirmwareVersion'] = hardware_intf_types.FirmwareVersion.default[1],
                ['PCBVersion'] = hardware_intf_types.PCBVersion.default[1],
                ['Manufacturer'] = hardware_intf_types.Manufacturer.default[1],
                ['AssetTag'] = hardware_intf_types.AssetTag.default[1],
                ['PartNumber'] = hardware_intf_types.PartNumber.default[1],
                ['ManufactureDate'] = hardware_intf_types.ManufactureDate.default[1],
                ['Slot'] = hardware_intf_types.Slot.default[1],
                ['Model'] = hardware_intf_types.Model.default[1],
                ['UUID'] = hardware_intf_types.UUID.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = hardware_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local SASPhy = {
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.PhyError'] = {
            ['PhyId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = phy_error_intf_types.PhyId
            },
            ['InvalidDwordCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = phy_error_intf_types.InvalidDwordCount
            },
            ['LossDwordSyncCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = phy_error_intf_types.LossDwordSyncCount
            },
            ['PhyResetProblemCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = phy_error_intf_types.PhyResetProblemCount
            },
            ['RunningDisparityErrorCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = phy_error_intf_types.RunningDisparityErrorCount
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Controllers/:Id1/SASPhy/:Id2'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.PhyError'] = {
            ['property_defaults'] = {
                ['PhyId'] = phy_error_intf_types.PhyId.default[1],
                ['InvalidDwordCount'] = phy_error_intf_types.InvalidDwordCount.default[1],
                ['LossDwordSyncCount'] = phy_error_intf_types.LossDwordSyncCount.default[1],
                ['PhyResetProblemCount'] = phy_error_intf_types.PhyResetProblemCount.default[1],
                ['RunningDisparityErrorCount'] = phy_error_intf_types.RunningDisparityErrorCount.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = phy_error_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local DiskArray = {
    ['table_name'] = 't_diskarrays_info',
    ['prop_configs'] = {
        ['RefPDSlots'] = {['baseType'] = 'U8[]', ['readOnly'] = true, ['validator'] = disk_array_class_types.RefPDSlots},
        ['RefPDEnclosures'] = {
            ['baseType'] = 'U16[]',
            ['readOnly'] = true,
            ['validator'] = disk_array_class_types.RefPDEnclosures
        }
    },
    ['default_props'] = {
        ['RefPDSlots'] = disk_array_class_types.RefPDSlots.default[1],
        ['RefPDEnclosures'] = disk_array_class_types.RefPDEnclosures.default[1]
    },
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.DiskArray'] = {
            ['Id'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['primaryKey'] = true,
                ['validator'] = disk_array_intf_types.Id
            },
            ['UsedSpaceMiB'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.UsedSpaceMiB
            },
            ['TotalFreeSpaceMiB'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.TotalFreeSpaceMiB
            },
            ['FreeBlocksSpaceMiB'] = {
                ['baseType'] = 'U32[]',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.FreeBlocksSpaceMiB
            },
            ['RefVolumes'] = {
                ['baseType'] = 'U16[]',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.RefVolumes
            },
            ['RefDrives'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.RefDrives
            },
            ['DriveNumPerSpan'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.DriveNumPerSpan
            },
            ['RAIDType'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.RAIDType
            },
            ['AverageDriveFreeSpaceMiB'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = disk_array_intf_types.AverageDriveFreeSpaceMiB
            },
            ['RefControllerId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['primaryKey'] = true,
                ['validator'] = disk_array_intf_types.RefControllerId
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Controllers/:ControllerId/DiskArrays/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.DiskArray'] = {
            ['property_defaults'] = {
                ['Id'] = disk_array_intf_types.Id.default[1],
                ['UsedSpaceMiB'] = disk_array_intf_types.UsedSpaceMiB.default[1],
                ['TotalFreeSpaceMiB'] = disk_array_intf_types.TotalFreeSpaceMiB.default[1],
                ['FreeBlocksSpaceMiB'] = disk_array_intf_types.FreeBlocksSpaceMiB.default[1],
                ['RefVolumes'] = disk_array_intf_types.RefVolumes.default[1],
                ['RefDrives'] = disk_array_intf_types.RefDrives.default[1],
                ['DriveNumPerSpan'] = disk_array_intf_types.DriveNumPerSpan.default[1],
                ['RAIDType'] = disk_array_intf_types.RAIDType.default[1],
                ['AverageDriveFreeSpaceMiB'] = disk_array_intf_types.AverageDriveFreeSpaceMiB.default[1],
                ['RefControllerId'] = disk_array_intf_types.RefControllerId.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = disk_array_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local Drive = {
    ['table_name'] = 't_storage_drive',
    ['alias_map'] = {
        ['InventorySerialNumber'] = {
            ['original_name'] = 'SerialNumber',
            ['interface'] = 'bmc.kepler.Inventory.Hardware'
        },
        ['InventoryFirmwareVersion'] = {
            ['original_name'] = 'FirmwareVersion',
            ['interface'] = 'bmc.kepler.Inventory.Hardware'
        },
        ['InventoryManufacturer'] = {
            ['original_name'] = 'Manufacturer',
            ['interface'] = 'bmc.kepler.Inventory.Hardware'
        },
        ['InventoryModel'] = {['original_name'] = 'Model', ['interface'] = 'bmc.kepler.Inventory.Hardware'}
    },
    ['prop_configs'] = {
        ['LocateReg'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = drive_class_types.LocateReg},
        ['FaultReg'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = drive_class_types.FaultReg},
        ['ActivationLed'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = drive_class_types.ActivationLed},
        ['PhysicalLocation'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'String',
            ['validator'] = drive_class_types.PhysicalLocation
        },
        ['PassThrough'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['default'] = 255,
            ['validator'] = drive_class_types.PassThrough
        },
        ['HddBackplaneStartSlot'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['default'] = 255,
            ['validator'] = drive_class_types.HddBackplaneStartSlot
        },
        ['RelativeSlot'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = drive_class_types.RelativeSlot},
        ['LinkFault'] = {
            ['usage'] = {'ResetPer'},
            ['baseType'] = 'Boolean',
            ['default'] = false,
            ['validator'] = drive_class_types.LinkFault
        },
        ['SetLocateLed'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = drive_class_types.SetLocateLed},
        ['SetFaultLed'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = drive_class_types.SetFaultLed},
        ['CommandTimeoutTimes'] = {
            ['usage'] = {'PoweroffPer'},
            ['baseType'] = 'U32',
            ['default'] = 0,
            ['validator'] = drive_class_types.CommandTimeoutTimes
        },
        ['UnexpectedSenseTimes'] = {
            ['usage'] = {'PoweroffPer'},
            ['baseType'] = 'U32',
            ['default'] = 0,
            ['validator'] = drive_class_types.UnexpectedSenseTimes
        }
    },
    ['default_props'] = {
        ['LocateReg'] = drive_class_types.LocateReg.default[1],
        ['FaultReg'] = drive_class_types.FaultReg.default[1],
        ['ActivationLed'] = drive_class_types.ActivationLed.default[1],
        ['PhysicalLocation'] = drive_class_types.PhysicalLocation.default[1],
        ['PassThrough'] = 255,
        ['HddBackplaneStartSlot'] = 255,
        ['RelativeSlot'] = drive_class_types.RelativeSlot.default[1],
        ['LinkFault'] = false,
        ['SetLocateLed'] = drive_class_types.SetLocateLed.default[1],
        ['SetFaultLed'] = drive_class_types.SetFaultLed.default[1],
        ['CommandTimeoutTimes'] = 0,
        ['UnexpectedSenseTimes'] = 0
    },
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.Drive'] = {
            ['NodeId'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_drive_intf_types.NodeId
            },
            ['Id'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['primaryKey'] = true,
                ['validator'] = systems_storage_drive_intf_types.Id
            },
            ['SlotNumber'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.SlotNumber
            },
            ['Name'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_drive_intf_types.Name
            },
            ['Presence'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.Presence
            },
            ['LocateLed'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_drive_intf_types.LocateLed
            },
            ['FaultLed'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_drive_intf_types.FaultLed
            },
            ['EnclosureId'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 65535,
                ['validator'] = systems_storage_drive_intf_types.EnclosureId
            },
            ['LocationIndicatorState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.LocationIndicatorState
            },
            ['CapacityMiB'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 4294967295,
                ['validator'] = systems_storage_drive_intf_types.CapacityMiB
            },
            ['TemperatureCelsius'] = {
                ['baseType'] = 'S16',
                ['readOnly'] = true,
                ['options'] = {['volatile'] = true, ['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.TemperatureCelsius
            },
            ['Model'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 'N/A',
                ['validator'] = systems_storage_drive_intf_types.Model
            },
            ['Protocol'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.Protocol
            },
            ['CapableSpeedGbs'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.CapableSpeedGbs
            },
            ['NegotiatedSpeedGbs'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.NegotiatedSpeedGbs
            },
            ['MediaType'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.MediaType
            },
            ['FirmwareStatus'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.FirmwareStatus
            },
            ['SerialNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'ResetPer'},
                ['default'] = 'N/A',
                ['validator'] = systems_storage_drive_intf_types.SerialNumber
            },
            ['Manufacturer'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 'N/A',
                ['validator'] = systems_storage_drive_intf_types.Manufacturer
            },
            ['PowerOnHours'] = {
                ['baseType'] = 'Double',
                ['readOnly'] = true,
                ['options'] = {['volatile'] = true, ['emitsChangedSignal'] = 'false'},
                ['validator'] = systems_storage_drive_intf_types.PowerOnHours
            },
            ['Revision'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 'N/A',
                ['validator'] = systems_storage_drive_intf_types.Revision
            },
            ['RotationSpeedRPM'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.RotationSpeedRPM
            },
            ['BlockSizeBytes'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.BlockSizeBytes
            },
            ['SASAddress1'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.SASAddress1
            },
            ['SASAddress2'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.SASAddress2
            },
            ['Location'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = systems_storage_drive_intf_types.Location
            },
            ['DeviceName'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['default'] = 'N/A',
                ['validator'] = systems_storage_drive_intf_types.DeviceName
            },
            ['PredictedMediaLifeLeftPercent'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.PredictedMediaLifeLeftPercent
            },
            ['PredictedFailCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.PredictedFailCount
            },
            ['MediaErrorCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.MediaErrorCount
            },
            ['OtherErrorCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.OtherErrorCount
            },
            ['PatrolState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.PatrolState
            },
            ['PowerState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.PowerState
            },
            ['RebuildState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = systems_storage_drive_intf_types.RebuildState
            },
            ['RebuildProgress'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['volatile'] = true, ['emitsChangedSignal'] = 'true'},
                ['validator'] = systems_storage_drive_intf_types.RebuildProgress
            },
            ['BootPriority'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.BootPriority
            },
            ['FormFactor'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = systems_storage_drive_intf_types.FormFactor
            },
            ['HotspareType'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.HotspareType
            },
            ['RefControllerId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 255,
                ['validator'] = systems_storage_drive_intf_types.RefControllerId
            },
            ['RefVolumeList'] = {
                ['baseType'] = 'U16[]',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.RefVolumeList
            },
            ['RefDiskArrayId'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.RefDiskArrayId
            },
            ['ManufacturerId'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.ManufacturerId
            },
            ['PCIeLinkSpeed'] = {
                ['baseType'] = 'Double',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.PCIeLinkSpeed
            },
            ['ResourceId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = systems_storage_drive_intf_types.ResourceId
            },
            ['ContainerPhysicalContext'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = systems_storage_drive_intf_types.ContainerPhysicalContext
            }
        },
        ['bmc.kepler.Systems.Storage.Drive.AddrInfo'] = {
            ['Type'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['default'] = 'N/A',
                ['validator'] = addr_info_intf_types.Type
            },
            ['SocketId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = addr_info_intf_types.SocketId
            },
            ['SlotId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = addr_info_intf_types.SlotId
            },
            ['PortId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['validator'] = addr_info_intf_types.PortId
            },
            ['RootBDF'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['usage'] = {'CSR'},
                ['default'] = 'N/A',
                ['validator'] = addr_info_intf_types.RootBDF
            }
        },
        ['bmc.kepler.Systems.Storage.Drive.DriveStatus'] = {
            ['Missing'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.Missing
            },
            ['PredictiveFailure'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.PredictiveFailure
            },
            ['InAFailedArray'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.InAFailedArray
            },
            ['CapacityError'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.CapacityError
            },
            ['FirmwareStatusError'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.FirmwareStatusError
            },
            ['Failure'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.Failure
            },
            ['Health'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['validator'] = drive_status_intf_types.Health
            }
        },
        ['bmc.kepler.Systems.Storage.Drive.SAS.SMART'] = {
            ['StripTemperatureCelsius'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sassmart_intf_types.StripTemperatureCelsius
            },
            ['ElementsInGrownDefectList'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sassmart_intf_types.ElementsInGrownDefectList
            },
            ['ElementsInPrimaryDefectList'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['usage'] = {'ResetPer'},
                ['default'] = 4294967295,
                ['validator'] = sassmart_intf_types.ElementsInPrimaryDefectList
            },
            ['ManufacturedInWeekOfYear'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = sassmart_intf_types.ManufacturedInWeekOfYear
            },
            ['BlocksSentToInitiator'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sassmart_intf_types.BlocksSentToInitiator
            },
            ['BlocksReceivedFromInitiator'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sassmart_intf_types.BlocksReceivedFromInitiator
            },
            ['UntilNextInterSMARTTestMinutes'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = sassmart_intf_types.UntilNextInterSMARTTestMinutes
            },
            ['LastPrefailEventSeqNum'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = sassmart_intf_types.LastPrefailEventSeqNum
            }
        },
        ['bmc.kepler.Metric'] = {},
        ['bmc.kepler.Inventory.Hardware'] = {
            ['AssetType'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.AssetType
            },
            ['AssetName'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.AssetName
            },
            ['SerialNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventorySerialNumber',
                ['validator'] = hardware_intf_types.SerialNumber
            },
            ['FirmwareVersion'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventoryFirmwareVersion',
                ['validator'] = hardware_intf_types.FirmwareVersion
            },
            ['PCBVersion'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.PCBVersion
            },
            ['Manufacturer'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventoryManufacturer',
                ['validator'] = hardware_intf_types.Manufacturer
            },
            ['AssetTag'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = hardware_intf_types.AssetTag},
            ['PartNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.PartNumber
            },
            ['ManufactureDate'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = hardware_intf_types.ManufactureDate
            },
            ['Slot'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = hardware_intf_types.Slot},
            ['Model'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['alias'] = 'InventoryModel',
                ['validator'] = hardware_intf_types.Model
            },
            ['UUID'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = hardware_intf_types.UUID}
        },
        ['bmc.kepler.Systems.Storage.Drive.DriveSubHealth'] = {
            ['EstimatedRemainingLifespanInsufficient'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'ResetPer'},
                ['validator'] = drive_sub_health_intf_types.EstimatedRemainingLifespanInsufficient
            },
            ['SLCSpareBlockPercentage'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = drive_sub_health_intf_types.SLCSpareBlockPercentage
            },
            ['TLCSpareBlockPercentage'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['default'] = 255,
                ['validator'] = drive_sub_health_intf_types.TLCSpareBlockPercentage
            },
            ['EstimatedRemainingLifespan'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'PoweroffPer'},
                ['default'] = 4294967295,
                ['validator'] = drive_sub_health_intf_types.EstimatedRemainingLifespan
            },
            ['IODeteriorationHealthCode'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['usage'] = {'CSR', 'PoweroffPer'},
                ['validator'] = drive_sub_health_intf_types.IODeteriorationHealthCode
            }
        },
        ['bmc.kepler.Systems.Storage.Drive.NVMe'] = {
            ['LifeUsedPercentage'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = nv_me_intf_types.LifeUsedPercentage
            }
        },
        ['bmc.kepler.Systems.Storage.Drive.NVMe.SMART'] = {
            ['AvailableSpare'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = nv_me_smart_intf_types.AvailableSpare
            },
            ['CriticalWarning'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = nv_me_smart_intf_types.CriticalWarning
            },
            ['UsedPercentage'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'false'},
                ['validator'] = nv_me_smart_intf_types.UsedPercentage
            },
            ['Status'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = nv_me_smart_intf_types.Status}
        },
        ['bmc.kepler.Systems.Storage.Drive.Diagnose'] = {},
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_method_configs'] = {
        ['bmc.kepler.Systems.Storage.Drive'] = {
            ['SetLocationIndicatorState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'LocationIndicatorState'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetFaultIndicatorState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'FaultIndicatorState'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetFirmwareStatus'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'FirmwareStatus'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetHotspareType'] = {
                ['req'] = {
                    {['baseType'] = 'U8', ['param'] = 'HotspareType'}, {['baseType'] = 'U16', ['param'] = 'VolumeId'}
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetBootPriority'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'BootPriority'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetPatrolState'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'PatrolState'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['CryptoErase'] = {['req'] = {}, ['rsp'] = {}, ['privilege'] = {'BasicSetting'}}
        },
        ['bmc.kepler.Metric'] = {
            ['GetData'] = {
                ['req'] = {{['baseType'] = 'String[]', ['param'] = 'MetricName'}},
                ['rsp'] = {
                    {['baseType'] = 'Array', ['items'] = {['$ref'] = '#/defs/DataCollectionItem'}, ['param'] = 'Val'}
                }
            },
            ['GetItems'] = {
                ['req'] = {},
                ['rsp'] = {
                    {['baseType'] = 'String', ['param'] = 'Component'},
                    {['baseType'] = 'Array', ['items'] = {['$ref'] = '#/defs/TagProp'}, ['param'] = 'Classification'},
                    {['baseType'] = 'Array', ['items'] = {['$ref'] = '#/defs/TagProp'}, ['param'] = 'Identification'},
                    {['baseType'] = 'String[]', ['param'] = 'MetricName'}
                }
            },
            ['SynDataAcquisitionEnable'] = {['req'] = {{['baseType'] = 'U8', ['param'] = 'Enabled'}}, ['rsp'] = {}}
        },
        ['bmc.kepler.Systems.Storage.Drive.NVMe'] = {
            ['GetSmartInfo'] = {
                ['req'] = {{['baseType'] = 'U16', ['param'] = 'Vendor'}},
                ['rsp'] = {{['baseType'] = 'U8[]', ['param'] = 'MessageResponse'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['SendNvmeMICommand'] = {
                ['req'] = {
                    {['baseType'] = 'U8', ['param'] = 'Opcode'}, {['baseType'] = 'U32', ['param'] = 'Dword0'},
                    {['baseType'] = 'U32', ['param'] = 'Dword1'}, {['baseType'] = 'U8[]', ['param'] = 'RequestData'}
                },
                ['rsp'] = {
                    {['baseType'] = 'U8', ['param'] = 'Status'}, {['baseType'] = 'U32', ['param'] = 'NVMeResponse'},
                    {['baseType'] = 'U8[]', ['param'] = 'ResponseData'}
                },
                ['privilege'] = {'UserMgmt'}
            },
            ['GetTelemetryData'] = {
                ['req'] = {{['baseType'] = 'String', ['enum'] = {'Host', 'Controller'}, ['param'] = 'DataType'}},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['GetIdentifyData'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'CNSValue'}},
                ['rsp'] = {{['baseType'] = 'U8[]', ['param'] = 'MessageResponse'}},
                ['privilege'] = {'BasicSetting'}
            }
        },
        ['bmc.kepler.Systems.Storage.Drive.Diagnose'] = {
            ['CollectDiagnoseData'] = {
                ['req'] = {{['baseType'] = 'String[]', ['param'] = 'DiagnoseDataType'}},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['GetDiagnoseData'] = {
                ['req'] = {{['baseType'] = 'String[]', ['param'] = 'DiagnoseDataType'}},
                ['rsp'] = {{['baseType'] = 'Dictionary', ['$ref'] = '#/defs/Data', ['param'] = 'DiagnoseData'}},
                ['privilege'] = {'BasicSetting'}
            }
        }
    },
    ['mdb_signal_configs'] = {
        ['bmc.kepler.Metric'] = {
            ['CollectSignal'] = {
                {['baseType'] = 'String', ['param'] = 'MetricName'}, {['baseType'] = 'String', ['param'] = 'TagPath'}
            }
        }
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Drives/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.Drive'] = {
            ['property_defaults'] = {
                ['NodeId'] = systems_storage_drive_intf_types.NodeId.default[1],
                ['Id'] = systems_storage_drive_intf_types.Id.default[1],
                ['SlotNumber'] = 255,
                ['Name'] = systems_storage_drive_intf_types.Name.default[1],
                ['Presence'] = 255,
                ['LocateLed'] = systems_storage_drive_intf_types.LocateLed.default[1],
                ['FaultLed'] = systems_storage_drive_intf_types.FaultLed.default[1],
                ['EnclosureId'] = 65535,
                ['LocationIndicatorState'] = systems_storage_drive_intf_types.LocationIndicatorState.default[1],
                ['CapacityMiB'] = 4294967295,
                ['TemperatureCelsius'] = 255,
                ['Model'] = 'N/A',
                ['Protocol'] = 255,
                ['CapableSpeedGbs'] = 255,
                ['NegotiatedSpeedGbs'] = 255,
                ['MediaType'] = 255,
                ['FirmwareStatus'] = 255,
                ['SerialNumber'] = 'N/A',
                ['Manufacturer'] = 'N/A',
                ['PowerOnHours'] = systems_storage_drive_intf_types.PowerOnHours.default[1],
                ['Revision'] = 'N/A',
                ['RotationSpeedRPM'] = systems_storage_drive_intf_types.RotationSpeedRPM.default[1],
                ['BlockSizeBytes'] = systems_storage_drive_intf_types.BlockSizeBytes.default[1],
                ['SASAddress1'] = systems_storage_drive_intf_types.SASAddress1.default[1],
                ['SASAddress2'] = systems_storage_drive_intf_types.SASAddress2.default[1],
                ['Location'] = systems_storage_drive_intf_types.Location.default[1],
                ['DeviceName'] = 'N/A',
                ['PredictedMediaLifeLeftPercent'] = 255,
                ['PredictedFailCount'] = systems_storage_drive_intf_types.PredictedFailCount.default[1],
                ['MediaErrorCount'] = systems_storage_drive_intf_types.MediaErrorCount.default[1],
                ['OtherErrorCount'] = systems_storage_drive_intf_types.OtherErrorCount.default[1],
                ['PatrolState'] = systems_storage_drive_intf_types.PatrolState.default[1],
                ['PowerState'] = systems_storage_drive_intf_types.PowerState.default[1],
                ['RebuildState'] = systems_storage_drive_intf_types.RebuildState.default[1],
                ['RebuildProgress'] = systems_storage_drive_intf_types.RebuildProgress.default[1],
                ['BootPriority'] = systems_storage_drive_intf_types.BootPriority.default[1],
                ['FormFactor'] = systems_storage_drive_intf_types.FormFactor.default[1],
                ['HotspareType'] = systems_storage_drive_intf_types.HotspareType.default[1],
                ['RefControllerId'] = 255,
                ['RefVolumeList'] = systems_storage_drive_intf_types.RefVolumeList.default[1],
                ['RefDiskArrayId'] = systems_storage_drive_intf_types.RefDiskArrayId.default[1],
                ['ManufacturerId'] = systems_storage_drive_intf_types.ManufacturerId.default[1],
                ['PCIeLinkSpeed'] = systems_storage_drive_intf_types.PCIeLinkSpeed.default[1],
                ['ResourceId'] = systems_storage_drive_intf_types.ResourceId.default[1],
                ['ContainerPhysicalContext'] = systems_storage_drive_intf_types.ContainerPhysicalContext.default[1]
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['SetLocationIndicatorState'] = privilege.BasicSetting,
                    ['SetFaultIndicatorState'] = privilege.BasicSetting,
                    ['SetFirmwareStatus'] = privilege.BasicSetting,
                    ['SetHotspareType'] = privilege.BasicSetting,
                    ['SetBootPriority'] = privilege.BasicSetting,
                    ['SetPatrolState'] = privilege.BasicSetting,
                    ['CryptoErase'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = systems_storage_drive_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.AddrInfo'] = {
            ['property_defaults'] = {
                ['Type'] = 'N/A',
                ['SocketId'] = addr_info_intf_types.SocketId.default[1],
                ['SlotId'] = addr_info_intf_types.SlotId.default[1],
                ['PortId'] = addr_info_intf_types.PortId.default[1],
                ['RootBDF'] = 'N/A'
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = addr_info_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.DriveStatus'] = {
            ['property_defaults'] = {
                ['Missing'] = drive_status_intf_types.Missing.default[1],
                ['PredictiveFailure'] = drive_status_intf_types.PredictiveFailure.default[1],
                ['InAFailedArray'] = drive_status_intf_types.InAFailedArray.default[1],
                ['CapacityError'] = drive_status_intf_types.CapacityError.default[1],
                ['FirmwareStatusError'] = drive_status_intf_types.FirmwareStatusError.default[1],
                ['Failure'] = drive_status_intf_types.Failure.default[1],
                ['Health'] = drive_status_intf_types.Health.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = drive_status_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.SAS.SMART'] = {
            ['property_defaults'] = {
                ['StripTemperatureCelsius'] = sassmart_intf_types.StripTemperatureCelsius.default[1],
                ['ElementsInGrownDefectList'] = sassmart_intf_types.ElementsInGrownDefectList.default[1],
                ['ElementsInPrimaryDefectList'] = 4294967295,
                ['ManufacturedInWeekOfYear'] = sassmart_intf_types.ManufacturedInWeekOfYear.default[1],
                ['BlocksSentToInitiator'] = sassmart_intf_types.BlocksSentToInitiator.default[1],
                ['BlocksReceivedFromInitiator'] = sassmart_intf_types.BlocksReceivedFromInitiator.default[1],
                ['UntilNextInterSMARTTestMinutes'] = sassmart_intf_types.UntilNextInterSMARTTestMinutes.default[1],
                ['LastPrefailEventSeqNum'] = sassmart_intf_types.LastPrefailEventSeqNum.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = sassmart_intf_types
        },
        ['bmc.kepler.Metric'] = {
            ['property_defaults'] = {},
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = metric_intf_types
        },
        ['bmc.kepler.Inventory.Hardware'] = {
            ['property_defaults'] = {
                ['AssetType'] = hardware_intf_types.AssetType.default[1],
                ['AssetName'] = hardware_intf_types.AssetName.default[1],
                ['SerialNumber'] = hardware_intf_types.SerialNumber.default[1],
                ['FirmwareVersion'] = hardware_intf_types.FirmwareVersion.default[1],
                ['PCBVersion'] = hardware_intf_types.PCBVersion.default[1],
                ['Manufacturer'] = hardware_intf_types.Manufacturer.default[1],
                ['AssetTag'] = hardware_intf_types.AssetTag.default[1],
                ['PartNumber'] = hardware_intf_types.PartNumber.default[1],
                ['ManufactureDate'] = hardware_intf_types.ManufactureDate.default[1],
                ['Slot'] = hardware_intf_types.Slot.default[1],
                ['Model'] = hardware_intf_types.Model.default[1],
                ['UUID'] = hardware_intf_types.UUID.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = hardware_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.DriveSubHealth'] = {
            ['property_defaults'] = {
                ['EstimatedRemainingLifespanInsufficient'] = drive_sub_health_intf_types.EstimatedRemainingLifespanInsufficient
                    .default[1],
                ['SLCSpareBlockPercentage'] = 255,
                ['TLCSpareBlockPercentage'] = 255,
                ['EstimatedRemainingLifespan'] = 4294967295,
                ['IODeteriorationHealthCode'] = drive_sub_health_intf_types.IODeteriorationHealthCode.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = drive_sub_health_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.NVMe'] = {
            ['property_defaults'] = {['LifeUsedPercentage'] = nv_me_intf_types.LifeUsedPercentage.default[1]},
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['GetSmartInfo'] = privilege.BasicSetting,
                    ['SendNvmeMICommand'] = privilege.UserMgmt,
                    ['GetTelemetryData'] = privilege.BasicSetting,
                    ['GetIdentifyData'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = nv_me_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.NVMe.SMART'] = {
            ['property_defaults'] = {
                ['AvailableSpare'] = nv_me_smart_intf_types.AvailableSpare.default[1],
                ['CriticalWarning'] = nv_me_smart_intf_types.CriticalWarning.default[1],
                ['UsedPercentage'] = nv_me_smart_intf_types.UsedPercentage.default[1],
                ['Status'] = nv_me_smart_intf_types.Status.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = nv_me_smart_intf_types
        },
        ['bmc.kepler.Systems.Storage.Drive.Diagnose'] = {
            ['property_defaults'] = {},
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['CollectDiagnoseData'] = privilege.BasicSetting,
                    ['GetDiagnoseData'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = drive_diagnose_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local Drives = {
    ['table_name'] = 't_drives_info',
    ['prop_configs'] = {['Id'] = {['primaryKey'] = true, ['baseType'] = 'U8', ['validator'] = drives_class_types.Id}},
    ['default_props'] = {['Id'] = drives_class_types.Id.default[1]},
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.Drives'] = {
            ['MaxTemperatureCelsius'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = drives_intf_types.MaxTemperatureCelsius
            },
            ['LogAutoCollectEnable'] = {
                ['baseType'] = 'Boolean',
                ['readOnly'] = false,
                ['usage'] = {'PoweroffPer'},
                ['default'] = true,
                ['validator'] = drives_intf_types.LogAutoCollectEnable
            },
            ['LogAutoCollectInterval'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = false,
                ['usage'] = {'PoweroffPer'},
                ['default'] = 24,
                ['validator'] = drives_intf_types.LogAutoCollectInterval
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_method_configs'] = {
        ['bmc.kepler.Systems.Storage.Drives'] = {
            ['CollectIODeteriorationDiagInfo'] = {
                ['req'] = {},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['GetDrivesSubHealthDiagInfo'] = {
                ['req'] = {{['baseType'] = 'String', ['param'] = 'SubHealthType'}},
                ['rsp'] = {
                    {
                        ['baseType'] = 'Array',
                        ['items'] = {['$ref'] = '#/defs/DriveList'},
                        ['param'] = 'SubHealthDiagInfoList'
                    }
                },
                ['privilege'] = {'BasicSetting'}
            },
            ['GetNvmeDriveRawData'] = {
                ['req'] = {{['baseType'] = 'U16', ['param'] = 'index'}},
                ['rsp'] = {{['baseType'] = 'String', ['param'] = 'NvmeDriveData'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['GetNvmeDriveCount'] = {['req'] = {}, ['rsp'] = {{['baseType'] = 'U16', ['param'] = 'NvmeDriveCount'}}},
            ['SetDriveSubHealthDiagResult'] = {
                ['req'] = {
                    {
                        ['baseType'] = 'Array',
                        ['items'] = {['$ref'] = '#/defs/KeyValueTable'},
                        ['param'] = 'SubHealthDiagResult'
                    }
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['StartCollectLog'] = {
                ['req'] = {{['baseType'] = 'String', ['param'] = 'DriveName'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            }
        }
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Drives'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.Drives'] = {
            ['property_defaults'] = {
                ['MaxTemperatureCelsius'] = drives_intf_types.MaxTemperatureCelsius.default[1],
                ['LogAutoCollectEnable'] = true,
                ['LogAutoCollectInterval'] = 24
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['CollectIODeteriorationDiagInfo'] = privilege.BasicSetting,
                    ['GetDrivesSubHealthDiagInfo'] = privilege.BasicSetting,
                    ['GetNvmeDriveRawData'] = privilege.BasicSetting,
                    ['SetDriveSubHealthDiagResult'] = privilege.BasicSetting,
                    ['StartCollectLog'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = drives_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local ReplicaDrive = {
    ['table_name'] = 't_ReplicaDrives_info',
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.ReplicaDrive'] = {
            ['Id'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['usage'] = {'CSR'},
                ['primaryKey'] = true,
                ['validator'] = replica_drive_intf_types.Id
            },
            ['SerialNumber'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = replica_drive_intf_types.SerialNumber
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/ReplicaDrives/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.ReplicaDrive'] = {
            ['property_defaults'] = {
                ['Id'] = replica_drive_intf_types.Id.default[1],
                ['SerialNumber'] = replica_drive_intf_types.SerialNumber.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = replica_drive_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local Volume = {
    ['table_name'] = 't_volumes_info',
    ['prop_configs'] = {['NumDrivePerSpan'] = {['baseType'] = 'U8', ['validator'] = volume_class_types.NumDrivePerSpan}},
    ['default_props'] = {['NumDrivePerSpan'] = volume_class_types.NumDrivePerSpan.default[1]},
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.Volume'] = {
            ['Id'] = {
                ['baseType'] = 'U16',
                ['readOnly'] = true,
                ['primaryKey'] = true,
                ['validator'] = volume_intf_types.Id
            },
            ['VolumeName'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.VolumeName
            },
            ['OptimumIOSizeBytes'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.OptimumIOSizeBytes
            },
            ['DefaultReadPolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.DefaultReadPolicy
            },
            ['DefaultWritePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.DefaultWritePolicy
            },
            ['State'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['default'] = 255,
                ['validator'] = volume_intf_types.State
            },
            ['RAIDType'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = volume_intf_types.RAIDType},
            ['CapacityBytes'] = {
                ['baseType'] = 'U64',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.CapacityBytes
            },
            ['DriveCachePolicy'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.DriveCachePolicy
            },
            ['CurrentForegroundInitState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.CurrentForegroundInitState
            },
            ['ForegroundInitProgress'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['options'] = {['volatile'] = true, ['emitsChangedSignal'] = 'true'},
                ['validator'] = volume_intf_types.ForegroundInitProgress
            },
            ['CurrentReadPolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.CurrentReadPolicy
            },
            ['CurrentWritePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.CurrentWritePolicy
            },
            ['BootPriority'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.BootPriority
            },
            ['BootEnable'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = volume_intf_types.BootEnable},
            ['OSDriveName'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.OSDriveName
            },
            ['BGIEnable'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = volume_intf_types.BGIEnable},
            ['SSDCachecadeVolume'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.SSDCachecadeVolume
            },
            ['ConsistencyCheck'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.ConsistencyCheck
            },
            ['SSDCachingEnable'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.SSDCachingEnable
            },
            ['AssociatedVolumes'] = {
                ['baseType'] = 'U16[]',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.AssociatedVolumes
            },
            ['AssociatedCacheCadeVolume'] = {
                ['baseType'] = 'U16[]',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.AssociatedCacheCadeVolume
            },
            ['DefaultCachePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.DefaultCachePolicy
            },
            ['AccessPolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.AccessPolicy
            },
            ['CurrentCachePolicy'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.CurrentCachePolicy
            },
            ['CacheLineSizeKiB'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.CacheLineSizeKiB
            },
            ['AccelerationMethod'] = {
                ['baseType'] = 'String',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.AccelerationMethod
            },
            ['RebuildProgress'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.RebuildProgress
            },
            ['InitializationMode'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.InitializationMode
            },
            ['RebuildState'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.RebuildState
            },
            ['RefControllerId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['primaryKey'] = true,
                ['validator'] = volume_intf_types.RefControllerId
            },
            ['RefDriveList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.RefDriveList
            },
            ['RefDiskArrayList'] = {
                ['baseType'] = 'U16[]',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.RefDiskArrayList
            },
            ['HotSpareDriveList'] = {
                ['baseType'] = 'String[]',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.HotSpareDriveList
            },
            ['SpanCount'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = volume_intf_types.SpanCount},
            ['MaxResizableSizeBytes'] = {
                ['baseType'] = 'U64',
                ['readOnly'] = true,
                ['validator'] = volume_intf_types.MaxResizableSizeBytes
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_method_configs'] = {
        ['bmc.kepler.Systems.Storage.Volume'] = {
            ['SetName'] = {
                ['req'] = {{['baseType'] = 'String', ['param'] = 'Name'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetReadPolicy'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'ReadPolicy'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetWritePolicy'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'WritePolicy'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetBootable'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'BootPriority'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetIOPolicy'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'IOPolicy'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetBGIEnable'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'BGIEnabled'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetAccessPolicy'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'AccessPolicy'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetDiskCachePolicy'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'DiskCachePolicy'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['StartForegroundInit'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'InitType'}},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['CancelForegroundInit'] = {
                ['req'] = {},
                ['rsp'] = {{['baseType'] = 'U32', ['param'] = 'TaskId'}},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetCachecadeEnable'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'AssociateCachecade'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetAccelerator'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'Accelerator'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetCapacitySize'] = {
                ['req'] = {
                    {['baseType'] = 'U32', ['param'] = 'CapacitySize'},
                    {['baseType'] = 'U8', ['param'] = 'CapacityUnit'}
                },
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            },
            ['SetStripSize'] = {
                ['req'] = {{['baseType'] = 'U8', ['param'] = 'StripSize'}},
                ['rsp'] = {},
                ['privilege'] = {'BasicSetting'}
            }
        }
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Controllers/:ControllerId/Volumes/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.Volume'] = {
            ['property_defaults'] = {
                ['Id'] = volume_intf_types.Id.default[1],
                ['VolumeName'] = volume_intf_types.VolumeName.default[1],
                ['OptimumIOSizeBytes'] = volume_intf_types.OptimumIOSizeBytes.default[1],
                ['DefaultReadPolicy'] = volume_intf_types.DefaultReadPolicy.default[1],
                ['DefaultWritePolicy'] = volume_intf_types.DefaultWritePolicy.default[1],
                ['State'] = 255,
                ['RAIDType'] = volume_intf_types.RAIDType.default[1],
                ['CapacityBytes'] = volume_intf_types.CapacityBytes.default[1],
                ['DriveCachePolicy'] = volume_intf_types.DriveCachePolicy.default[1],
                ['CurrentForegroundInitState'] = volume_intf_types.CurrentForegroundInitState.default[1],
                ['ForegroundInitProgress'] = volume_intf_types.ForegroundInitProgress.default[1],
                ['CurrentReadPolicy'] = volume_intf_types.CurrentReadPolicy.default[1],
                ['CurrentWritePolicy'] = volume_intf_types.CurrentWritePolicy.default[1],
                ['BootPriority'] = volume_intf_types.BootPriority.default[1],
                ['BootEnable'] = volume_intf_types.BootEnable.default[1],
                ['OSDriveName'] = volume_intf_types.OSDriveName.default[1],
                ['BGIEnable'] = volume_intf_types.BGIEnable.default[1],
                ['SSDCachecadeVolume'] = volume_intf_types.SSDCachecadeVolume.default[1],
                ['ConsistencyCheck'] = volume_intf_types.ConsistencyCheck.default[1],
                ['SSDCachingEnable'] = volume_intf_types.SSDCachingEnable.default[1],
                ['AssociatedVolumes'] = volume_intf_types.AssociatedVolumes.default[1],
                ['AssociatedCacheCadeVolume'] = volume_intf_types.AssociatedCacheCadeVolume.default[1],
                ['DefaultCachePolicy'] = volume_intf_types.DefaultCachePolicy.default[1],
                ['AccessPolicy'] = volume_intf_types.AccessPolicy.default[1],
                ['CurrentCachePolicy'] = volume_intf_types.CurrentCachePolicy.default[1],
                ['CacheLineSizeKiB'] = volume_intf_types.CacheLineSizeKiB.default[1],
                ['AccelerationMethod'] = volume_intf_types.AccelerationMethod.default[1],
                ['RebuildProgress'] = volume_intf_types.RebuildProgress.default[1],
                ['InitializationMode'] = volume_intf_types.InitializationMode.default[1],
                ['RebuildState'] = volume_intf_types.RebuildState.default[1],
                ['RefControllerId'] = volume_intf_types.RefControllerId.default[1],
                ['RefDriveList'] = volume_intf_types.RefDriveList.default[1],
                ['RefDiskArrayList'] = volume_intf_types.RefDiskArrayList.default[1],
                ['HotSpareDriveList'] = volume_intf_types.HotSpareDriveList.default[1],
                ['SpanCount'] = volume_intf_types.SpanCount.default[1],
                ['MaxResizableSizeBytes'] = volume_intf_types.MaxResizableSizeBytes.default[1]
            },
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['methods'] = {
                    ['SetName'] = privilege.BasicSetting,
                    ['SetReadPolicy'] = privilege.BasicSetting,
                    ['SetWritePolicy'] = privilege.BasicSetting,
                    ['SetBootable'] = privilege.BasicSetting,
                    ['SetIOPolicy'] = privilege.BasicSetting,
                    ['SetBGIEnable'] = privilege.BasicSetting,
                    ['SetAccessPolicy'] = privilege.BasicSetting,
                    ['SetDiskCachePolicy'] = privilege.BasicSetting,
                    ['StartForegroundInit'] = privilege.BasicSetting,
                    ['CancelForegroundInit'] = privilege.BasicSetting,
                    ['SetCachecadeEnable'] = privilege.BasicSetting,
                    ['SetAccelerator'] = privilege.BasicSetting,
                    ['SetCapacitySize'] = privilege.BasicSetting,
                    ['SetStripSize'] = privilege.BasicSetting
                }
            },
            ['interface_types'] = volume_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local Battery = {
    ['table_name'] = 't_batterys_info',
    ['prop_configs'] = {
        ['RefController'] = {['baseType'] = 'U8', ['validator'] = battery_class_types.RefController},
        ['RefControllerDeviceName'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'String',
            ['primaryKey'] = true,
            ['validator'] = battery_class_types.RefControllerDeviceName
        },
        ['RefControllerSlotId'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['validator'] = battery_class_types.RefControllerSlotId
        },
        ['RefControllerTypeId'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['validator'] = battery_class_types.RefControllerTypeId
        }
    },
    ['default_props'] = {
        ['RefController'] = battery_class_types.RefController.default[1],
        ['RefControllerDeviceName'] = battery_class_types.RefControllerDeviceName.default[1],
        ['RefControllerSlotId'] = battery_class_types.RefControllerSlotId.default[1],
        ['RefControllerTypeId'] = battery_class_types.RefControllerTypeId.default[1]
    },
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.Battery'] = {
            ['Name'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = battery_intf_types.Name},
            ['State'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = battery_intf_types.State},
            ['Fault'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['default'] = 255,
                ['validator'] = battery_intf_types.Fault
            },
            ['HealthStatus'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['options'] = {['emitsChangedSignal'] = 'true'},
                ['validator'] = battery_intf_types.HealthStatus
            },
            ['Health'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = battery_intf_types.Health},
            ['TemperatureCelsius'] = {
                ['baseType'] = 'S16',
                ['readOnly'] = true,
                ['options'] = {['volatile'] = true, ['emitsChangedSignal'] = 'true'},
                ['usage'] = {'CSR'},
                ['validator'] = battery_intf_types.TemperatureCelsius
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Controllers/:Id/Battery'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.Battery'] = {
            ['property_defaults'] = {
                ['Name'] = battery_intf_types.Name.default[1],
                ['State'] = battery_intf_types.State.default[1],
                ['Fault'] = 255,
                ['HealthStatus'] = battery_intf_types.HealthStatus.default[1],
                ['Health'] = battery_intf_types.Health.default[1],
                ['TemperatureCelsius'] = battery_intf_types.TemperatureCelsius.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = battery_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local Nvme = {
    ['table_name'] = 't_nvme_info',
    ['prop_configs'] = {
        ['Slot'] = {
            ['primaryKey'] = true,
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['validator'] = nvme_class_types.Slot
        },
        ['MediaType'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = nvme_class_types.MediaType},
        ['Protocol'] = {['usage'] = {'CSR'}, ['baseType'] = 'U8', ['validator'] = nvme_class_types.Protocol},
        ['Revision'] = {['usage'] = {'CSR'}, ['baseType'] = 'String', ['validator'] = nvme_class_types.Revision},
        ['PredictedMediaLifeLeftPercent'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['validator'] = nvme_class_types.PredictedMediaLifeLeftPercent
        },
        ['VPDChip'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Chip.BlockIO',
            ['validator'] = nvme_class_types.VPDChip
        },
        ['SSDChip'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Chip.BlockIO',
            ['validator'] = nvme_class_types.SSDChip
        },
        ['RefComponent'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Systems.PcieAddrInfo',
            ['validator'] = nvme_class_types.RefComponent
        },
        ['TemperatureCelsius'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['validator'] = nvme_class_types.TemperatureCelsius
        },
        ['Failure'] = {['usage'] = {'CSR'}, ['baseType'] = 'U16', ['validator'] = nvme_class_types.Failure},
        ['PredictiveFailure'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U16',
            ['validator'] = nvme_class_types.PredictiveFailure
        },
        ['SerialNumber'] = {['usage'] = {}, ['baseType'] = 'String', ['validator'] = nvme_class_types.SerialNumber}
    },
    ['default_props'] = {
        ['Slot'] = nvme_class_types.Slot.default[1],
        ['MediaType'] = nvme_class_types.MediaType.default[1],
        ['Protocol'] = nvme_class_types.Protocol.default[1],
        ['Revision'] = nvme_class_types.Revision.default[1],
        ['PredictedMediaLifeLeftPercent'] = nvme_class_types.PredictedMediaLifeLeftPercent.default[1],
        ['VPDChip'] = nvme_class_types.VPDChip.default[1],
        ['SSDChip'] = nvme_class_types.SSDChip.default[1],
        ['RefComponent'] = nvme_class_types.RefComponent.default[1],
        ['TemperatureCelsius'] = nvme_class_types.TemperatureCelsius.default[1],
        ['Failure'] = nvme_class_types.Failure.default[1],
        ['PredictiveFailure'] = nvme_class_types.PredictiveFailure.default[1],
        ['SerialNumber'] = nvme_class_types.SerialNumber.default[1]
    }
}

local VirtualVPDConnect = {
    ['table_name'] = 't_vpd_connect',
    ['prop_configs'] = {
        ['Slot'] = {
            ['primaryKey'] = true,
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['validator'] = virtual_vpd_connect_class_types.Slot
        },
        ['RefVPDChip'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Chip.BlockIO',
            ['validator'] = virtual_vpd_connect_class_types.RefVPDChip
        },
        ['RefConnector'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Connector',
            ['validator'] = virtual_vpd_connect_class_types.RefConnector
        },
        ['RefPolicyConnector'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8[]',
            ['refInterface'] = 'bmc.kepler.Connector',
            ['validator'] = virtual_vpd_connect_class_types.RefPolicyConnector
        }
    },
    ['default_props'] = {
        ['Slot'] = virtual_vpd_connect_class_types.Slot.default[1],
        ['RefVPDChip'] = virtual_vpd_connect_class_types.RefVPDChip.default[1],
        ['RefConnector'] = virtual_vpd_connect_class_types.RefConnector.default[1],
        ['RefPolicyConnector'] = virtual_vpd_connect_class_types.RefPolicyConnector.default[1]
    }
}

local Port = {
    ['prop_configs'] = {},
    ['default_props'] = {},
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.SASMetrics'] = {
            ['ControllerId'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = true,
                ['validator'] = sas_metrics_intf_types.ControllerId
            },
            ['InvalidDwordCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sas_metrics_intf_types.InvalidDwordCount
            },
            ['LossDwordSyncCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sas_metrics_intf_types.LossDwordSyncCount
            },
            ['PhyResetProblemCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sas_metrics_intf_types.PhyResetProblemCount
            },
            ['RunningDisparityErrorCount'] = {
                ['baseType'] = 'U32',
                ['readOnly'] = true,
                ['validator'] = sas_metrics_intf_types.RunningDisparityErrorCount
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/Controllers/:ControllerId/Ports/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.SASMetrics'] = {
            ['property_defaults'] = {
                ['ControllerId'] = sas_metrics_intf_types.ControllerId.default[1],
                ['InvalidDwordCount'] = sas_metrics_intf_types.InvalidDwordCount.default[1],
                ['LossDwordSyncCount'] = sas_metrics_intf_types.LossDwordSyncCount.default[1],
                ['PhyResetProblemCount'] = sas_metrics_intf_types.PhyResetProblemCount.default[1],
                ['RunningDisparityErrorCount'] = sas_metrics_intf_types.RunningDisparityErrorCount.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = sas_metrics_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local DriveInfoTable = {
    ['table_name'] = 't_drive_info',
    ['prop_configs'] = {
        ['Id'] = {
            ['primaryKey'] = true,
            ['baseType'] = 'String',
            ['usage'] = {'PoweroffPer'},
            ['validator'] = drive_info_table_class_types.Id
        }
    },
    ['default_props'] = {['Id'] = drive_info_table_class_types.Id.default[1]}
}

local DrivesTableInfo = {
    ['table_name'] = 't_drives_table_info',
    ['prop_configs'] = {
        ['Id'] = {
            ['primaryKey'] = true,
            ['baseType'] = 'String',
            ['usage'] = {'PoweroffPer'},
            ['validator'] = drives_table_info_class_types.Id
        },
        ['TemperatureCelsius'] = {
            ['baseType'] = 'U8',
            ['usage'] = {'PoweroffPer'},
            ['validator'] = drives_table_info_class_types.TemperatureCelsius
        },
        ['IsAlerted'] = {
            ['baseType'] = 'Boolean',
            ['usage'] = {'PoweroffPer'},
            ['validator'] = drives_table_info_class_types.IsAlerted
        }
    },
    ['default_props'] = {
        ['Id'] = drives_table_info_class_types.Id.default[1],
        ['TemperatureCelsius'] = drives_table_info_class_types.TemperatureCelsius.default[1],
        ['IsAlerted'] = drives_table_info_class_types.IsAlerted.default[1]
    }
}

local DiskPartition = {
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Systems.Storage.DiskPartition'] = {
            ['Name'] = {['baseType'] = 'String', ['readOnly'] = true, ['validator'] = disk_partition_intf_types.Name},
            ['Usage'] = {['baseType'] = 'U8', ['readOnly'] = true, ['validator'] = disk_partition_intf_types.Usage},
            ['UsedCapacityGiB'] = {
                ['baseType'] = 'Double',
                ['readOnly'] = true,
                ['validator'] = disk_partition_intf_types.UsedCapacityGiB
            },
            ['TotalCapacityGiB'] = {
                ['baseType'] = 'Double',
                ['readOnly'] = true,
                ['validator'] = disk_partition_intf_types.TotalCapacityGiB
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Systems/:SystemId/Storage/DiskPartitions/:Id'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Systems.Storage.DiskPartition'] = {
            ['property_defaults'] = {
                ['Name'] = disk_partition_intf_types.Name.default[1],
                ['Usage'] = disk_partition_intf_types.Usage.default[1],
                ['UsedCapacityGiB'] = disk_partition_intf_types.UsedCapacityGiB.default[1],
                ['TotalCapacityGiB'] = disk_partition_intf_types.TotalCapacityGiB.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = disk_partition_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local StorageReset = {
    ['table_name'] = 't_storage_reset',
    ['prop_configs'] = {
        ['PerId'] = {['primaryKey'] = true, ['baseType'] = 'String', ['validator'] = storage_reset_class_types.PerId},
        ['Key'] = {['primaryKey'] = true, ['baseType'] = 'String', ['validator'] = storage_reset_class_types.Key},
        ['Value'] = {['baseType'] = 'String', ['validator'] = storage_reset_class_types.Value}
    },
    ['default_props'] = {
        ['PerId'] = storage_reset_class_types.PerId.default[1],
        ['Key'] = storage_reset_class_types.Key.default[1],
        ['Value'] = storage_reset_class_types.Value.default[1]
    }
}

local GlobalStorageConfigTable = {
    ['table_name'] = 't_storage_global_config_table',
    ['prop_configs'] = {
        ['Id'] = {
            ['baseType'] = 'String',
            ['primaryKey'] = true,
            ['usage'] = {'PoweroffPer'},
            ['default'] = 'GlobalStorageConfig',
            ['validator'] = global_storage_config_table_class_types.Id
        },
        ['DiskPartitionUsagePercentageThreshold'] = {
            ['baseType'] = 'U8',
            ['default'] = 100,
            ['usage'] = {'PoweroffPer'},
            ['validator'] = global_storage_config_table_class_types.DiskPartitionUsagePercentageThreshold
        }
    },
    ['default_props'] = {['Id'] = 'GlobalStorageConfig', ['DiskPartitionUsagePercentageThreshold'] = 100}
}

local NVMeConfig = {
    ['prop_configs'] = {
        ['MultiHostMappings'] = {
            ['usage'] = {'CSR'},
            ['baseType'] = 'Array',
            ['items'] = {['baseType'] = 'Struct', ['$ref'] = 'types.json#/defs/Configuration'},
            ['validator'] = nv_me_config_class_types.MultiHostMappings
        }
    },
    ['default_props'] = {['MultiHostMappings'] = nv_me_config_class_types.MultiHostMappings.default[1]}
}

local StorageSetting = {
    ['table_name'] = 't_storage_setting_table_info',
    ['prop_configs'] = {
        ['Id'] = {
            ['primaryKey'] = true,
            ['usage'] = {'CSR'},
            ['baseType'] = 'U8',
            ['default'] = 0,
            ['validator'] = storage_setting_class_types.Id
        }
    },
    ['default_props'] = {['Id'] = 0},
    ['mdb_prop_configs'] = {
        ['bmc.kepler.Chassis.Storage.StorageSetting'] = {
            ['SSDMediaLifeLeftPercentThreshold'] = {
                ['baseType'] = 'U8',
                ['readOnly'] = false,
                ['options'] = {['emitsChangedSignal'] = 'true'},
                ['usage'] = {'CSR', 'PoweroffPer'},
                ['privilege'] = {['read'] = {'ReadOnly'}, ['write'] = {'DiagnoseMgmt'}},
                ['default'] = 5,
                ['validator'] = storage_setting_intf_types.SSDMediaLifeLeftPercentThreshold
            }
        },
        ['bmc.kepler.Object.Properties'] = mdb.OBJECT_PROPERTIES_INTERFACE_PROP_CONFIGS
    },
    ['mdb_classes'] = mdb.get_class_obj('/bmc/kepler/Chassis/:ChassisId/Storage'),
    ['new_mdb_objects'] = mdb.new_objects_builder({
        ['bmc.kepler.Chassis.Storage.StorageSetting'] = {
            ['property_defaults'] = {['SSDMediaLifeLeftPercentThreshold'] = 5},
            ['privileges'] = {
                ['path'] = privilege.ReadOnly,
                ['props'] = {
                    ['SSDMediaLifeLeftPercentThreshold'] = {
                        ['read'] = privilege.ReadOnly,
                        ['write'] = privilege.DiagnoseMgmt
                    }
                }
            },
            ['interface_types'] = storage_setting_intf_types
        },
        ['bmc.kepler.Object.Properties'] = {
            ['property_defaults'] = {
                ['ClassName'] = properties_intf_types.ClassName.default[1],
                ['ObjectName'] = properties_intf_types.ObjectName.default[1],
                ['ObjectIdentifier'] = properties_intf_types.ObjectIdentifier.default[1]
            },
            ['privileges'] = {['path'] = privilege.ReadOnly},
            ['interface_types'] = properties_intf_types
        }
    })
}

local M = {}

function M.init(bus)
    class('StorageConfig', StorageConfig):set_bus(bus)
    class('Controller', Controller):set_bus(bus)
    class('SASPhy', SASPhy):set_bus(bus)
    class('DiskArray', DiskArray):set_bus(bus)
    class('Drive', Drive):set_bus(bus)
    class('Drives', Drives):set_bus(bus)
    class('ReplicaDrive', ReplicaDrive):set_bus(bus)
    class('Volume', Volume):set_bus(bus)
    class('Battery', Battery):set_bus(bus)
    class('Nvme', Nvme):set_bus(bus)
    class('VirtualVPDConnect', VirtualVPDConnect):set_bus(bus)
    class('Port', Port):set_bus(bus)
    class('DriveInfoTable', DriveInfoTable):set_bus(bus)
    class('DrivesTableInfo', DrivesTableInfo):set_bus(bus)
    class('DiskPartition', DiskPartition):set_bus(bus)
    class('StorageReset', StorageReset):set_bus(bus)
    class('GlobalStorageConfigTable', GlobalStorageConfigTable):set_bus(bus)
    class('NVMeConfig', NVMeConfig):set_bus(bus)
    class('StorageSetting', StorageSetting):set_bus(bus)
end

-- The callback needs to be registered during app initialization
function M.ImplStorageConfigPhyBitErrorMockData(cb)
    class('StorageConfig')['bmc.kepler.Debug.Storage.PhyBitError'].MockData = function(obj, ctx, ...)
        local req = phy_bit_error_intf_types.MockDataReq.new(...):validate(nil, nil, true)
        local rsp = phy_bit_error_intf_types.MockDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplStorageConfigRecordDriveSpareBlockMockRecordSpareBlock(cb)
    class('StorageConfig')['bmc.kepler.Debug.Storage.RecordDriveSpareBlock'].MockRecordSpareBlock =
        function(obj, ctx, ...)
            local req = record_drive_spare_block_intf_types.MockRecordSpareBlockReq.new(...):validate(nil, nil, true)
            local rsp =
                record_drive_spare_block_intf_types.MockRecordSpareBlockRsp.new(cb(obj, ctx, req:unpack())):validate()
            return rsp:unpack(true)
        end
end

-- The callback needs to be registered during app initialization
function M.ImplStorageConfigReleaseStorageControllerGetControllerInfo(cb)
    class('StorageConfig')['bmc.kepler.Release.Storage.Controller'].GetControllerInfo = function(obj, ctx, ...)
        local req = release_storage_controller_intf_types.GetControllerInfoReq.new(...):validate(nil, nil, true)
        local rsp =
            release_storage_controller_intf_types.GetControllerInfoRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplStorageConfigReleaseStorageDriveGetDriveDetails(cb)
    class('StorageConfig')['bmc.kepler.Release.Storage.Drive'].GetDriveDetails = function(obj, ctx, ...)
        local req = release_storage_drive_intf_types.GetDriveDetailsReq.new(...):validate(nil, nil, true)
        local rsp = release_storage_drive_intf_types.GetDriveDetailsRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetBootDevices(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetBootDevices = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetBootDevicesReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_controller_intf_types.SetBootDevicesRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetJBODState(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetJBODState = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetJBODStateReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_controller_intf_types.SetJBODStateRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetSmarterCopyBackState(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetSmarterCopyBackState = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetSmarterCopyBackStateReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.SetSmarterCopyBackStateRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerRestoreDefaultSettings(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].RestoreDefaultSettings = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.RestoreDefaultSettingsReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.RestoreDefaultSettingsRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetCopybackState(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetCopybackState = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetCopybackStateReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_controller_intf_types.SetCopybackStateRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetMaintainPDFailHistoryState(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetMaintainPDFailHistoryState = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetMaintainPDFailHistoryStateReq.new(...):validate(nil, nil,
            true)
        local rsp = systems_storage_controller_intf_types.SetMaintainPDFailHistoryStateRsp.new(
            cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetWorkMode(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetWorkMode = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetWorkModeReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_controller_intf_types.SetWorkModeRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerImportForeignConfig(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].ImportForeignConfig = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.ImportForeignConfigReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.ImportForeignConfigRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerDumpLog(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].DumpLog = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.DumpLogReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_controller_intf_types.DumpLogRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerClearForeignConfig(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].ClearForeignConfig = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.ClearForeignConfigReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.ClearForeignConfigRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetNoBatteryWriteCache(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetNoBatteryWriteCache = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetNoBatteryWriteCacheReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.SetNoBatteryWriteCacheRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetReadCachePercent(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetReadCachePercent = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetReadCachePercentReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.SetReadCachePercentRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerSystemsStorageControllerSetWriteCachePolicy(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller'].SetWriteCachePolicy = function(obj, ctx, ...)
        local req = systems_storage_controller_intf_types.SetWriteCachePolicyReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_controller_intf_types.SetWriteCachePolicyRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerConsistencyCheckEnable(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'].Enable = function(obj, ctx, ...)
        local req = consistency_check_intf_types.EnableReq.new(...):validate(nil, nil, true)
        local rsp = consistency_check_intf_types.EnableRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerConsistencyCheckDisable(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'].Disable = function(obj, ctx, ...)
        local req = consistency_check_intf_types.DisableReq.new(...):validate(nil, nil, true)
        local rsp = consistency_check_intf_types.DisableRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerConsistencyCheckSetParameters(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.ConsistencyCheck'].SetParameters =
        function(obj, ctx, ...)
            local req = consistency_check_intf_types.SetParametersReq.new(...):validate(nil, nil, true)
            local rsp = consistency_check_intf_types.SetParametersRsp.new(cb(obj, ctx, req:unpack())):validate()
            return rsp:unpack(true)
        end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerVolumeManageCreateVolumeInNewArray(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.VolumeManage'].CreateVolumeInNewArray =
        function(obj, ctx, ...)
            local req = volume_manage_intf_types.CreateVolumeInNewArrayReq.new(...):validate(nil, nil, true)
            local rsp = volume_manage_intf_types.CreateVolumeInNewArrayRsp.new(cb(obj, ctx, req:unpack())):validate()
            return rsp:unpack(true)
        end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerVolumeManageDeleteVolume(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.VolumeManage'].DeleteVolume = function(obj, ctx, ...)
        local req = volume_manage_intf_types.DeleteVolumeReq.new(...):validate(nil, nil, true)
        local rsp = volume_manage_intf_types.DeleteVolumeRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerVolumeManageCreateVolumeInExisingtArray(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.VolumeManage'].CreateVolumeInExisingtArray = function(
        obj, ctx, ...)
        local req = volume_manage_intf_types.CreateVolumeInExisingtArrayReq.new(...):validate(nil, nil, true)
        local rsp = volume_manage_intf_types.CreateVolumeInExisingtArrayRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerVolumeManageCreateCachecadeVolume(cb)
    class('Controller')['bmc.kepler.Systems.Storage.Controller.VolumeManage'].CreateCachecadeVolume =
        function(obj, ctx, ...)
            local req = volume_manage_intf_types.CreateCachecadeVolumeReq.new(...):validate(nil, nil, true)
            local rsp = volume_manage_intf_types.CreateCachecadeVolumeRsp.new(cb(obj, ctx, req:unpack())):validate()
            return rsp:unpack(true)
        end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerRetirementDataWipe(cb)
    class('Controller')['bmc.kepler.LifeCycle.Retirement'].DataWipe = function(obj, ctx, ...)
        local req = retirement_intf_types.DataWipeReq.new(...):validate(nil, nil, true)
        local rsp = retirement_intf_types.DataWipeRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplControllerRetirementGetReport(cb)
    class('Controller')['bmc.kepler.LifeCycle.Retirement'].GetReport = function(obj, ctx, ...)
        local req = retirement_intf_types.GetReportReq.new(...):validate(nil, nil, true)
        local rsp = retirement_intf_types.GetReportRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveSetLocationIndicatorState(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].SetLocationIndicatorState = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.SetLocationIndicatorStateReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_drive_intf_types.SetLocationIndicatorStateRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveSetFaultIndicatorState(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].SetFaultIndicatorState = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.SetFaultIndicatorStateReq.new(...):validate(nil, nil, true)
        local rsp =
            systems_storage_drive_intf_types.SetFaultIndicatorStateRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveSetFirmwareStatus(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].SetFirmwareStatus = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.SetFirmwareStatusReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_drive_intf_types.SetFirmwareStatusRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveSetHotspareType(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].SetHotspareType = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.SetHotspareTypeReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_drive_intf_types.SetHotspareTypeRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveSetBootPriority(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].SetBootPriority = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.SetBootPriorityReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_drive_intf_types.SetBootPriorityRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveSetPatrolState(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].SetPatrolState = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.SetPatrolStateReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_drive_intf_types.SetPatrolStateRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveSystemsStorageDriveCryptoErase(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive'].CryptoErase = function(obj, ctx, ...)
        local req = systems_storage_drive_intf_types.CryptoEraseReq.new(...):validate(nil, nil, true)
        local rsp = systems_storage_drive_intf_types.CryptoEraseRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveMetricGetData(cb)
    class('Drive')['bmc.kepler.Metric'].GetData = function(obj, ctx, ...)
        local req = metric_intf_types.GetDataReq.new(...):validate(nil, nil, true)
        local rsp = metric_intf_types.GetDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveMetricGetItems(cb)
    class('Drive')['bmc.kepler.Metric'].GetItems = function(obj, ctx, ...)
        local req = metric_intf_types.GetItemsReq.new(...):validate(nil, nil, true)
        local rsp = metric_intf_types.GetItemsRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveMetricSynDataAcquisitionEnable(cb)
    class('Drive')['bmc.kepler.Metric'].SynDataAcquisitionEnable = function(obj, ctx, ...)
        local req = metric_intf_types.SynDataAcquisitionEnableReq.new(...):validate(nil, nil, true)
        local rsp = metric_intf_types.SynDataAcquisitionEnableRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveNVMeGetSmartInfo(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive.NVMe'].GetSmartInfo = function(obj, ctx, ...)
        local req = nv_me_intf_types.GetSmartInfoReq.new(...):validate(nil, nil, true)
        local rsp = nv_me_intf_types.GetSmartInfoRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveNVMeSendNvmeMICommand(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive.NVMe'].SendNvmeMICommand = function(obj, ctx, ...)
        local req = nv_me_intf_types.SendNvmeMICommandReq.new(...):validate(nil, nil, true)
        local rsp = nv_me_intf_types.SendNvmeMICommandRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveNVMeGetTelemetryData(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive.NVMe'].GetTelemetryData = function(obj, ctx, ...)
        local req = nv_me_intf_types.GetTelemetryDataReq.new(...):validate(nil, nil, true)
        local rsp = nv_me_intf_types.GetTelemetryDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveNVMeGetIdentifyData(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive.NVMe'].GetIdentifyData = function(obj, ctx, ...)
        local req = nv_me_intf_types.GetIdentifyDataReq.new(...):validate(nil, nil, true)
        local rsp = nv_me_intf_types.GetIdentifyDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveDriveDiagnoseCollectDiagnoseData(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive.Diagnose'].CollectDiagnoseData = function(obj, ctx, ...)
        local req = drive_diagnose_intf_types.CollectDiagnoseDataReq.new(...):validate(nil, nil, true)
        local rsp = drive_diagnose_intf_types.CollectDiagnoseDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDriveDriveDiagnoseGetDiagnoseData(cb)
    class('Drive')['bmc.kepler.Systems.Storage.Drive.Diagnose'].GetDiagnoseData = function(obj, ctx, ...)
        local req = drive_diagnose_intf_types.GetDiagnoseDataReq.new(...):validate(nil, nil, true)
        local rsp = drive_diagnose_intf_types.GetDiagnoseDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDrivesDrivesCollectIODeteriorationDiagInfo(cb)
    class('Drives')['bmc.kepler.Systems.Storage.Drives'].CollectIODeteriorationDiagInfo = function(obj, ctx, ...)
        local req = drives_intf_types.CollectIODeteriorationDiagInfoReq.new(...):validate(nil, nil, true)
        local rsp = drives_intf_types.CollectIODeteriorationDiagInfoRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDrivesDrivesGetDrivesSubHealthDiagInfo(cb)
    class('Drives')['bmc.kepler.Systems.Storage.Drives'].GetDrivesSubHealthDiagInfo = function(obj, ctx, ...)
        local req = drives_intf_types.GetDrivesSubHealthDiagInfoReq.new(...):validate(nil, nil, true)
        local rsp = drives_intf_types.GetDrivesSubHealthDiagInfoRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDrivesDrivesGetNvmeDriveRawData(cb)
    class('Drives')['bmc.kepler.Systems.Storage.Drives'].GetNvmeDriveRawData = function(obj, ctx, ...)
        local req = drives_intf_types.GetNvmeDriveRawDataReq.new(...):validate(nil, nil, true)
        local rsp = drives_intf_types.GetNvmeDriveRawDataRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDrivesDrivesGetNvmeDriveCount(cb)
    class('Drives')['bmc.kepler.Systems.Storage.Drives'].GetNvmeDriveCount = function(obj, ctx, ...)
        local req = drives_intf_types.GetNvmeDriveCountReq.new(...):validate(nil, nil, true)
        local rsp = drives_intf_types.GetNvmeDriveCountRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDrivesDrivesSetDriveSubHealthDiagResult(cb)
    class('Drives')['bmc.kepler.Systems.Storage.Drives'].SetDriveSubHealthDiagResult = function(obj, ctx, ...)
        local req = drives_intf_types.SetDriveSubHealthDiagResultReq.new(...):validate(nil, nil, true)
        local rsp = drives_intf_types.SetDriveSubHealthDiagResultRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplDrivesDrivesStartCollectLog(cb)
    class('Drives')['bmc.kepler.Systems.Storage.Drives'].StartCollectLog = function(obj, ctx, ...)
        local req = drives_intf_types.StartCollectLogReq.new(...):validate(nil, nil, true)
        local rsp = drives_intf_types.StartCollectLogRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetName(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetName = function(obj, ctx, ...)
        local req = volume_intf_types.SetNameReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetNameRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetReadPolicy(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetReadPolicy = function(obj, ctx, ...)
        local req = volume_intf_types.SetReadPolicyReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetReadPolicyRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetWritePolicy(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetWritePolicy = function(obj, ctx, ...)
        local req = volume_intf_types.SetWritePolicyReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetWritePolicyRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetBootable(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetBootable = function(obj, ctx, ...)
        local req = volume_intf_types.SetBootableReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetBootableRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetIOPolicy(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetIOPolicy = function(obj, ctx, ...)
        local req = volume_intf_types.SetIOPolicyReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetIOPolicyRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetBGIEnable(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetBGIEnable = function(obj, ctx, ...)
        local req = volume_intf_types.SetBGIEnableReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetBGIEnableRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetAccessPolicy(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetAccessPolicy = function(obj, ctx, ...)
        local req = volume_intf_types.SetAccessPolicyReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetAccessPolicyRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetDiskCachePolicy(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetDiskCachePolicy = function(obj, ctx, ...)
        local req = volume_intf_types.SetDiskCachePolicyReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetDiskCachePolicyRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeStartForegroundInit(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].StartForegroundInit = function(obj, ctx, ...)
        local req = volume_intf_types.StartForegroundInitReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.StartForegroundInitRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeCancelForegroundInit(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].CancelForegroundInit = function(obj, ctx, ...)
        local req = volume_intf_types.CancelForegroundInitReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.CancelForegroundInitRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetCachecadeEnable(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetCachecadeEnable = function(obj, ctx, ...)
        local req = volume_intf_types.SetCachecadeEnableReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetCachecadeEnableRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetAccelerator(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetAccelerator = function(obj, ctx, ...)
        local req = volume_intf_types.SetAcceleratorReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetAcceleratorRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetCapacitySize(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetCapacitySize = function(obj, ctx, ...)
        local req = volume_intf_types.SetCapacitySizeReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetCapacitySizeRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

-- The callback needs to be registered during app initialization
function M.ImplVolumeVolumeSetStripSize(cb)
    class('Volume')['bmc.kepler.Systems.Storage.Volume'].SetStripSize = function(obj, ctx, ...)
        local req = volume_intf_types.SetStripSizeReq.new(...):validate(nil, nil, true)
        local rsp = volume_intf_types.SetStripSizeRsp.new(cb(obj, ctx, req:unpack())):validate()
        return rsp:unpack(true)
    end
end

return M
